libepp_nicbr
DomainFunctions.H
Go to the documentation of this file.
1 /* ${copyright}$ */
2 /* $Id: DomainFunctions.H 1277 2015-01-15 16:34:28Z rafael $ */
6 #ifndef __DOMAIN_FUNCTIONS_H__
7 #define __DOMAIN_FUNCTIONS_H__
9 
10 #if USE_BR_DOMAINS
11 #include "BrDomainCheck.H"
12 #include "BrDomainInfo.H"
13 #include "DomainTransfer.H"
14 #include "BrDomainCreate.H"
15 #include "BrDomainUpdate.H"
16 #include "BrDomainRenew.H"
17 #else
18 #include "DomainCheck.H"
19 #include "DomainInfo.H"
20 #include "DomainTransfer.H"
21 #include "DomainCreate.H"
22 #include "DomainUpdate.H"
23 #include "DomainRenew.H"
24 #endif //USE_BR_DOMAINS
25 
26 #include "DomainDelete.H"
27 #include "RegistrationPeriod.H"
28 
30 
35 int cmd_domain_help(string error_msg, string specific = "")
36 {
37  if (error_msg != "") {
38  printf("error: %s\n", error_msg.c_str());
39  }
40 
41  printf("domain command syntax help:\n");
42  printf("\n");
43 
44  if (specific == "" || specific == "check") {
45  printf(" check <domain1> [domain2 ... domainN]"
46 #if USE_BR_DOMAINS
47  " [-o organization]"
48 #endif //USE_BR_DOMAINS
49  "\n [-launch <claims|avail> phase[:name]]"
50  "\n");
51 
52  printf("\n");
53  }
54  if (specific == "" || specific == "info") {
55  printf(" info <domain> [-auth authInfoPw[:authInfoRoid]]"
56 #if USE_BR_DOMAINS
57  " [-t ticketNumber]"
58 #endif //USE_BR_DOMAINS
59  "\n [-launch phase[:name]] [-launch-include-mark] [-launch-id id]"
60  "\n");
61  printf("\n");
62  }
63  if (specific == "" || specific == "transfer") {
64  printf(" transfer <query|request|cancel|approve|reject> <domain> \n"
65  " [-auth authInfoPw[:authInfoRoid]]\n");
66  printf("\n");
67  }
68  if (specific == "" || specific == "create") {
69  printf(" create <domain> [-period time:unit]\n"
70  " [-ns nameserver[,ipversion:ipaddr][, ...] ...] "
71  "[-r registrant]"
72  "\n [-contact type=value ...] [-auth authInfoPw]"
73  "\n [-max-sig-life <maxSigLife>]"
74  "\n [-dnskey <flags> <protocol> <alg> <pubKey>]"
75  "\n [-ds <keyTag> <alg> <digestType> <digest> "
76  "[-maxlife <maxSigLife>]"
77  "\n [-keyData <flags> <protocol> <alg> <pubKey>]] "
78 #if USE_BR_DOMAINS
79  "\n <-o organization> [-rpflags flag1:flag2:flag3]"
80  "\n [-auto-renew <on|off>]"
81 #endif //USE_BR_DOMAINS
82  "\n [-launch sunrise <encoded-smd-file>]"
83  "\n [-launch claims <noticeId> <acceptedDate> <notAfter>]"
84  "\n");
85 
86  printf("\n");
87  }
88  if (specific == "" || specific == "delete") {
89  printf(" delete <domain>\n"
90  " [-launch phase[:name] <applicationId>]\n");
91  printf("\n");
92  }
93  if (specific == "" || specific == "renew") {
94  printf(" renew <domain> <-expdate curExpDate> [-period time:unit]\n");
95  printf("\n");
96  }
97  if (specific == "" || specific == "update") {
98  printf(" update <domain>\n"
99  " [-add-ns nameserver[,ipversion:ipaddr][, ...] ...]\n"
100  " [-add-contact type=value ...]\n"
101  " [-add-status status:lang:\"description\" ...]\n"
102  " [-max-sig-life <maxSigLife>]\n"
103  " [-add-dnskey <flags> <protocol> <alg> <pubKey>]\n"
104  " [-add-ds <keyTag> <alg> <digestType> <digest> "
105  "[-maxlife <maxSigLife>]\n"
106  " [-keyData <flags> <protocol> <alg> <pubKey>] ...]\n"
107  " [-secDNS-urgent]\n"
108  " [-rem-ns nameserver[,ipversion:ipaddr][, ...] ...]\n"
109  " [-rem-contact type=value ...]\n"
110  " [-rem-status status ...]\n"
111  " [-rem-dnskey <flags> <protocol> <alg> <pubKey>]\n"
112  " [-rem-ds <keyTag> <alg> <digestType> <digest> "
113  "[-maxlife <maxSigLife>]\n"
114  " [-keyData <flags> <protocol> <alg> <pubKey>] ...] \n"
115  " [-rem-ds-1.0 <keyTag>]\n"
116  " [-remove-all-secdns]\n"
117  " [-chg-ds <keyTag> <alg> <digestType> <digest> "
118  "[-maxlife <maxSigLife>]\n"
119  " [-keyData <flags> <protocol> <alg> <pubKey>]]\n"
120  " [-r registrant] [-auth authInfoPw]\n"
121 
122 #if USE_BR_DOMAINS
123  " [-t ticketNumber] [-rpflags flag1:flag2:flag3]\n"
124  " [-auto-renew <on|off>]\n"
125  " [-publication-status <published|onHold>]\n"
126  " [-o organization]\n"
127 #endif //USE_BR_DOMAINS
128  " [-rgp <request|report> [-rgp-report <preData> <postData> \n"
129  " <delTime> <resTime> <resReason> <statement> \n"
130  " <statement> [-rgp-other otherText]]]\n"
131  " [-launch phase[:name] <applicationId>]\n");
132  printf("\n");
133  }
134 
135  if (error_msg != "") {
136  return -1;
137  }
138 
139  return 0;
140 }
141 
143 
147 int cmd_domain_check(vector<string> &args)
148 {
149 #if USE_BR_DOMAINS
150  BrDomainCheck act;
151  BrDomainCheckCmd *cmd = act.get_command();
152 #else
153  DomainCheck act;
154  DomainCheckCmd *cmd = act.get_command();
155 #endif //USE_BR_DOMAINS
156  string cmd_name = "check";
157 
158  while (!args.empty()) {
159 #if USE_BR_DOMAINS
160  if (args[0] == "-o") {
161  // set organization
162  args.erase(args.begin());
163  if (args.empty()) {
164  return cmd_domain_help("organization parameter missing", cmd_name);
165  }
166  cmd->set_organization(args[0]);
167  args.erase(args.begin());
168  } else if (args[0] == "-launch") {
169 #else
170  if (args[0] == "-launch") {
171 #endif //USE_BR_DOMAINS
172 
173  args.erase(args.begin());
174 
175  if (args.empty()) {
176  return cmd_domain_help("type missing", cmd_name);
177  }
178 
179  LaunchCheckCmd launchCheckCmd;
180  launchCheckCmd.set_type(LaunchCheckCmd::Type::fromStr(args[0]));
181 
182  if (launchCheckCmd.get_type() == LaunchCheckCmd::Type::NONE) {
183  return cmd_domain_help("wrong type", cmd_name);
184  }
185 
186  args.erase(args.begin());
187 
188  if (args.empty()) {
189  return cmd_domain_help("phase missing", cmd_name);
190  }
191 
192  string phaseStr, name;
193  SheppStrUtil::split(args[0], phaseStr, name, ":", true);
194 
195  LaunchPhase::Value phase = LaunchPhase::fromStr(phaseStr);
196  if (phase == LaunchPhase::NONE) {
197  return cmd_domain_help("invalid phase", cmd_name);
198  }
199 
200  LaunchPhase launchPhase;
201  launchPhase.set_phase(phase);
202  launchPhase.set_name(name);
203  launchCheckCmd.set_phase(launchPhase);
204 
205  cmd->set_launch(launchCheckCmd);
206 
207  args.erase(args.begin());
208 
209  } else {
210  // insert domains
211  cmd->insert_domain(args[0]);
212  args.erase(args.begin());
213  }
214  }
215 
216  if (cmd->get_domains_list().empty()) {
217  return cmd_domain_help("no domain names specified", cmd_name);
218  }
219 
220  if (_debug) {
221  set<string> domains = cmd->get_domains_list();
222  set<string>::const_iterator it;
223  printf("names to be checked:\n");
224  for (it = domains.begin(); it != domains.end(); it++) {
225  printf(" [%s]\n", (*it).c_str());
226  }
227 
228 #if USE_BR_DOMAINS
229  if (cmd->get_organization() != "") {
230  printf(" organization: [%s]\n", cmd->get_organization().c_str());
231  }
232 #endif //USE_BR_DOMAINS
233  } // _debug
234 
235  if (process_action(act) != 0) {
236  return -1;
237  }
238 
239  return 0;
240  }
241 
243 
247  int cmd_domain_info(vector<string> &args)
248  {
249 #if USE_BR_DOMAINS
250  BrDomainInfo act;
251  BrDomainInfoCmd *cmd = act.get_command();
252 #else
253  DomainInfo act;
254  DomainInfoCmd *cmd = act.get_command();
255 #endif //USE_BR_DOMAINS
256  string cmd_name = "info";
257 
258  if (args.empty()) {
259  return cmd_domain_help("no domain name specified", cmd_name);
260  }
261 
262  // domain name MUST be the first attribute
263  cmd->set_name(args[0]);
264  args.erase(args.begin());
265 
266  LaunchInfoCmd launch;
267 
268  while (!args.empty()) {
269  if (args[0] == "-auth") {
270  // set authInfo
271  AuthInfo auth;
272  if (SheppObjSet::authInfo(auth, args) != 0) {
273  return cmd_domain_help("invalid auth", cmd_name);
274  }
275  cmd->set_authInfo(auth);
276 #if USE_BR_DOMAINS
277  } else if (args[0] == "-t") {
278  // ticketNumber
279  args.erase(args.begin());
280  if (args.empty()) {
281  return cmd_domain_help("ticket number parameter missing", cmd_name);
282  }
283  if (atoi(args[0].c_str()) <= 0) {
284  return cmd_domain_help("ticket parameter must be a positive integer",
285  cmd_name);
286  }
287  cmd->set_ticketNumber(atoi(args[0].c_str()));
288  args.erase(args.begin());
289 #endif //USE_BR_DOMAINS
290  } else if (args[0] == "-launch") {
291  args.erase(args.begin());
292 
293  if (args.empty()) {
294  return cmd_domain_help("phase missing", cmd_name);
295  }
296 
297  string phaseStr, name;
298  SheppStrUtil::split(args[0], phaseStr, name, ":", true);
299 
300  LaunchPhase::Value phase = LaunchPhase::fromStr(phaseStr);
301  if (phase == LaunchPhase::NONE) {
302  return cmd_domain_help("invalid phase", cmd_name);
303  }
304 
305  LaunchPhase launchPhase;
306  launchPhase.set_phase(phase);
307  launchPhase.set_name(name);
308  launch.set_phase(launchPhase);
309 
310  args.erase(args.begin());
311 
312  } else if (args[0] == "-launch-include-mark") {
313  args.erase(args.begin());
314  launch.set_includeMark(true);
315 
316  } else if (args[0] == "-launch-id") {
317  args.erase(args.begin());
318 
319  if (args.empty()) {
320  return cmd_domain_help("launch id missing", cmd_name);
321  }
322 
323  launch.set_applicationId(args[0]);
324  args.erase(args.begin());
325 
326  } else {
327  return cmd_domain_help("invalid syntax near \"" + args[0] + "\"",
328  cmd_name);
329  }
330  }
331 
332  cmd->set_launch(launch);
333 
334  if (_debug) {
335  printf("name to get info: [%s]\n", cmd->get_name().c_str());
336 
337 #if USE_BR_DOMAINS
338  if (cmd->get_ticketNumber() != 0) {
339  printf(" ticketNumber: [%d]\n", cmd->get_ticketNumber());
340  }
341 #endif //USE_BR_DOMAINS
342 
344  } // _debug
345 
346  if (process_action(act) != 0) {
347  return -1;
348  }
349 
350  return 0;
351  }
352 
354 
358  int cmd_domain_transfer(vector<string> &args)
359  {
360  DomainTransfer act;
361  DomainTransferCmd *cmd = act.get_command();
362  string cmd_name = "transfer";
363 
364  if (args.empty()) {
365  return cmd_domain_help("no operation specified", cmd_name);
366  }
367 
369  if (op == TransferOperation::NONE) {
370  return cmd_domain_help("invalid operation", cmd_name);
371  }
372 
373  cmd->set_operation(op);
374  args.erase(args.begin());
375 
376  if (args.empty()) {
377  return cmd_domain_help("no domain name specified", cmd_name);
378  }
379 
380  // domain name MUST be the first attribute
381  cmd->set_name(args[0]);
382  args.erase(args.begin());
383 
384  while (!args.empty()) {
385  if (args[0] == "-auth") {
386  // set authInfo
387  AuthInfo auth;
388  if (SheppObjSet::authInfo(auth, args) != 0) {
389  return cmd_domain_help("invalid auth", cmd_name);
390  }
391  cmd->set_authInfo(auth);
392  } else {
393  return cmd_domain_help("invalid syntax near \"" + args[0] + "\"",
394  cmd_name);
395  }
396  }
397 
398  if (process_action(act) != 0) {
399  return -1;
400  }
401 
402  return 0;
403  }
404 
406 
410  int cmd_domain_create(vector<string> &args)
411  {
412 #if USE_BR_DOMAINS
413  BrDomainCreate act;
414  BrDomainCreateCmd *cmd = act.get_command();
415 #else
416  DomainCreate act;
417  DomainCreateCmd *cmd = act.get_command();
418 #endif //USE_BR_DOMAINS
419  string cmd_name = "create";
420 
421  cmd->set_secDnsVersion(_serverSecDnsVersion);
422 
423  if (args.empty()) {
424  return cmd_domain_help("domain name missing", cmd_name);
425  }
426  // domain name MUST be the first attribute
427  cmd->set_name(args[0]);
428  args.erase(args.begin());
429 
430  while (!args.empty()) {
431  if (args[0] == "-period") {
432  //registration period
433  args.erase(args.begin());
434  if (args.empty()) {
435  return cmd_domain_help("period parameter missing", cmd_name);
436  }
437 
438  string time;
439  string unit;
440  if (SheppStrUtil::split(args[0], time, unit, ":", false) != 0) {
441  return cmd_domain_help("invalid period", cmd_name);
442  }
443 
444  int time_number = atoi(time.c_str());
445  if (time_number == 0) {
446  return cmd_domain_help("invalid period", cmd_name);
447  }
448 
449  cmd->set_period(time_number, unit);
450  args.erase(args.begin());
451  } else if (args[0] == "-ns") {
452  //nameserver
453  NameServer ns;
454  if (SheppObjSet::nameServer(ns, args) != 0) {
455  return cmd_domain_help("invalid nameserver", cmd_name);
456  }
457  cmd->insert_nameserver(ns);
458  } else if (args[0] == "-r") {
459  //registrant
460  args.erase(args.begin());
461  if (args.empty()) {
462  return cmd_domain_help("registrant parameter missing", cmd_name);
463  }
464  cmd->set_registrant(args[0]);
465  args.erase(args.begin());
466  } else if (args[0] == "-contact") {
467  //contact
468  args.erase(args.begin());
469  if (args.empty()) {
470  return cmd_domain_help("contact parameter missing", cmd_name);
471  }
472 
473  string type;
474  string value;
475  if (SheppStrUtil::split(args[0], type, value, "=", false) != 0) {
476  return cmd_domain_help("invalid contact", cmd_name);
477  }
478 
479  cmd->insert_contact(type, value);
480  args.erase(args.begin());
481 
482  } else if (args[0] == "-auth") {
483  //authInfo
484  AuthInfo auth;
485  if (SheppObjSet::authInfo(auth, args) != 0) {
486  return cmd_domain_help("invalid auth", cmd_name);
487  }
488 
489  // roid not allowed in domain create command
490  if (auth.get_roid_f() == true) {
491  return cmd_domain_help("invalid auth", cmd_name);
492  }
493 
494  cmd->set_authInfo(auth);
495  } else if (args[0] == "-dnskey") {
496  //DNSSEC data (RFC 5910)
497  KeyData dnskey;
498  string error_msg;
499  if (SheppObjSet::keyData(dnskey, args, error_msg) != 0) {
500  return cmd_domain_help(error_msg, cmd_name);
501  }
502  cmd->add_keyData(dnskey);
503  } else if (args[0] == "-ds") {
504  //DNSSEC data (RFC 4310/5910)
505  DSInfo ds;
506  string error_msg;
507  if (SheppObjSet::dsInfo(ds, args, error_msg) != 0) {
508  return cmd_domain_help(error_msg, cmd_name);
509  }
510  cmd->add_dsInfo(ds);
511  } else if (args[0] == "-max-sig-life") {
512  args.erase(args.begin());
513  if (args.empty()) {
514  return cmd_domain_help("maxSigLife parameter missing", cmd_name);
515  }
516  cmd->set_max_sig_life(atoi(args[0].c_str()));
517  args.erase(args.begin());
518 #if USE_BR_DOMAINS
519  } else if (args[0] == "-o") {
520  //organization
521  args.erase(args.begin());
522  if (args.empty()) {
523  return cmd_domain_help("organization parameter missing", cmd_name);
524  }
525  cmd->set_organization(args[0]);
526  args.erase(args.begin());
527  } else if (args[0] == "-rpflags") {
528  //releaseProcessFlags
529  args.erase(args.begin());
530  if (args.empty()) {
531  return cmd_domain_help("rpflags parameter missing", cmd_name);
532  }
534  string flag1;
535  string flag2;
536  string flag3;
537 
538  if (SheppStrUtil::split(args[0], flag1, flag2, ":", false) != 0) {
539  return cmd_domain_help("invalid rpflags", cmd_name);
540  }
541 
542  if (SheppStrUtil::split(flag2, flag2, flag3, ":", false) != 0) {
543  return cmd_domain_help("invalid rpflags", cmd_name);
544  }
545 
546  rpf.flag1 = (flag1 == "0") ? 0 : 1;
547  rpf.flag2 = (flag2 == "0") ? 0 : 1;
548  rpf.flag3 = (flag3 == "0") ? 0 : 1;
549 
550  cmd->set_releaseProcessFlags(rpf);
551  args.erase(args.begin());
552  } else if (args[0] == "-auto-renew") {
553  //auto-renew
554  args.erase(args.begin());
555  if (args.empty()) {
556  return cmd_domain_help("auto-renew parameter missing", cmd_name);
557  }
558  if (args[0] == "on") {
559  cmd->set_auto_renew(1);
560  } else if (args[0] == "off") {
561  cmd->set_auto_renew(0);
562  } else {
563  return cmd_domain_help("invalid auto-renew", cmd_name);
564  }
565  args.erase(args.begin());
566 #endif //USE_BR_DOMAINS
567  } else if (args[0] == "-launch") {
568  args.erase(args.begin());
569 
570  if (args.empty()) {
571  return cmd_domain_help("phase missing", cmd_name);
572  }
573 
574  string phaseStr, name;
575  SheppStrUtil::split(args[0], phaseStr, name, ":", true);
576 
577  LaunchPhase::Value phase = LaunchPhase::fromStr(phaseStr);
578  if (phase == LaunchPhase::NONE) {
579  return cmd_domain_help("invalid phase", cmd_name);
580  }
581 
582  LaunchPhase launchPhase;
583  launchPhase.set_phase(phase);
584  launchPhase.set_name(name);
585 
586  LaunchCreateCmd launchCmd;
587  launchCmd.set_phase(launchPhase);
588 
589  if (phase == LaunchPhase::SUNRISE) {
590  args.erase(args.begin());
591  if (args.empty()) {
592  return cmd_domain_help("encoded SMD file missing", cmd_name);
593  }
594 
595  ifstream fileStream(args[0].c_str());
596  if (!fileStream.good()) {
597  return cmd_domain_help("encoded SMD file not found", cmd_name);
598  }
599 
600  args.erase(args.begin());
601  string encodedSMDFile("");
602  bool reading = false;
603 
604  while(fileStream.good()) {
605  string line;
606  getline(fileStream, line);
607 
608  line = StrUtil::trim(line);
609  if (line == "-----BEGIN ENCODED SMD-----") {
610  reading = true;
611  continue;
612 
613  } else if (line == "-----END ENCODED SMD-----") {
614  reading = false;
615  continue;
616  }
617 
618  if (reading) {
619  encodedSMDFile += line;
620  }
621  }
622 
623  EncodedSignedMark encodedSMD;
624  encodedSMD.set_data(encodedSMDFile);
625 
626  list<EncodedSignedMark> encodedSMDs;
627  encodedSMDs.push_back(encodedSMD);
628  launchCmd.set_encodedSignedMarks(encodedSMDs);
629  } else if (phase == LaunchPhase::CLAIMS) {
630  ClaimsNotice notice;
631  string errorMsg;
632  if (SheppObjSet::claimsNotice(notice, args, errorMsg) != 0) {
633  return cmd_domain_help(errorMsg, cmd_name);
634  }
635 
636  launchCmd.set_notice(notice);
637  }
638  cmd->set_launch(launchCmd);
639  } else {
640  return cmd_domain_help("invalid syntax near \"" + args[0] + "\"",
641  cmd_name);
642  }
643  }
644 #if USE_BR_DOMAINS
645  if (cmd->get_organization() == "") {
646  return cmd_domain_help("organization is mandatory", cmd_name);
647  }
648 #endif //USE_BR_DOMAINS
649 
650  if (_debug) {
651  printf("creating domain: %s\n", cmd->get_name().c_str());
652 
653 #if USE_BR_DOMAINS
654  printf(" organization: %s\n", cmd->get_organization().c_str());
655 #endif //USE_BR_DOMAINS
656 
657  if (cmd->get_period().time != 0) {
658  printf(" period: %d %s\n", cmd->get_period().time,
659  cmd->get_period().unit.c_str());
660  }
661 
662  vector<NameServer> nss = cmd->get_nameservers();
663  vector<NameServer>::const_iterator nsit;
664  for (nsit = nss.begin(); nsit != nss.end(); nsit++) {
665  SheppPrint::nameserver(*nsit);
666  }
667 
668  if (cmd->get_registrant() != "") {
669  printf(" registrant: %s\n", cmd->get_registrant().c_str());
670  }
671 
672  map< string, string, less<string> > contacts = cmd->get_contacts();
673  map< string, string, less<string> >::const_iterator cit;
674  for (cit = contacts.begin(); cit != contacts.end(); cit++) {
675  printf(" contact %s: %s\n", (*cit).first.c_str(), (*cit).second.c_str());
676  }
677 
679 
680 #if USE_BR_DOMAINS
681  if (cmd->get_releaseProcessFlags().flag1 == 1 ||
682  cmd->get_releaseProcessFlags().flag2 == 1 ||
683  cmd->get_releaseProcessFlags().flag3 == 1) {
684  printf(" releaseProcessFlags: %d, %d, %d\n",
685  cmd->get_releaseProcessFlags().flag1,
686  cmd->get_releaseProcessFlags().flag2,
687  cmd->get_releaseProcessFlags().flag3);
688  }
689 
690  printf(" auto-renew: %d\n", cmd->get_auto_renew());
691 #endif //USE_BR_DOMAINS
692  } // _debug
693 
694  if (process_action(act) != 0) {
695  return -1;
696  }
697 
698  return 0;
699  }
700 
702 
706  int cmd_domain_delete(vector<string> &args)
707  {
708  DomainDelete act;
709  DomainDeleteCmd *cmd = act.get_command();
710 
711  string cmd_name = "delete";
712 
713  if (args.empty()) {
714  return cmd_domain_help("domain name missing", cmd_name);
715  }
716 
717  // domain name MUST be the first attribute
718  cmd->set_name(args[0]);
719  args.erase(args.begin());
720 
721  while (!args.empty()) {
722  if (args[0] == "-launch") {
723  args.erase(args.begin());
724 
725  if (args.empty()) {
726  return cmd_domain_help("phase missing", cmd_name);
727  }
728 
729  string phaseStr, name;
730  SheppStrUtil::split(args[0], phaseStr, name, ":", true);
731 
732  LaunchPhase::Value phase = LaunchPhase::fromStr(phaseStr);
733  if (phase == LaunchPhase::NONE) {
734  return cmd_domain_help("invalid phase", cmd_name);
735  }
736 
737  LaunchPhase launchPhase;
738  launchPhase.set_phase(phase);
739  launchPhase.set_name(name);
740 
741  args.erase(args.begin());
742 
743  if (args.empty()) {
744  return cmd_domain_help("application id missing", cmd_name);
745  }
746 
747  string applicationId = args[0];
748 
749  LaunchDeleteCmd launch;
750  launch.set_phase(launchPhase);
751  launch.set_applicationId(applicationId);
752  cmd->set_launch(launch);
753 
754  args.erase(args.begin());
755  } else {
756  return cmd_domain_help("invalid syntax near \"" + args[0] + "\"",
757  cmd_name);
758  }
759  }
760 
761  if (_debug) {
762  printf("deleting domain: %s\n", cmd->get_name().c_str());
763  }
764 
765  if (process_action(act) != 0) {
766  return -1;
767  }
768 
769  return 0;
770  }
771 
773 
777  int cmd_domain_renew(vector<string> &args)
778  {
779 #if USE_BR_DOMAINS
780  BrDomainRenew act;
781 #else
782  DomainRenew act;
783 #endif //USE_BR_DOMAINS
784  DomainRenewCmd *cmd = act.get_command();
785  string cmd_name = "renew";
786 
787  if (args.empty()) {
788  return cmd_domain_help("domain name missing", cmd_name);
789  }
790  // domain name MUST be the first attribute
791  cmd->set_name(args[0]);
792  args.erase(args.begin());
793 
794  while (!args.empty()) {
795  if (args[0] == "-expdate") {
796  //-expdate
797  args.erase(args.begin());
798  if (args.empty()) {
799  return cmd_domain_help("curExpDate missing", cmd_name);
800  }
801  cmd->set_curExpDate(args[0]);
802  args.erase(args.begin());
803  } else if (args[0] == "-period") {
804  args.erase(args.begin());
805  if (args.empty()) {
806  return cmd_domain_help("period missing", cmd_name);
807  }
808 
809  string str_time;
810  string unit;
811  if (SheppStrUtil::split(args[0], str_time, unit, ":", false) != 0) {
812  return cmd_domain_help("error setting period", cmd_name);
813  }
814 
815  RegistrationPeriod period;
816  period.time = atoi(str_time.c_str());
817  period.unit = unit;
818 
819  if (period.time == 0) {
820  return cmd_domain_help("invalid period", cmd_name);
821  }
822 
823  cmd->set_period(period);
824  args.erase(args.begin());
825  } else {
826  return cmd_domain_help("invalid syntax near \"" + args[0] + "\"",
827  cmd_name);
828  }
829  }
830 
831  if (cmd->get_curExpDate() == "") {
832  return cmd_domain_help("curExpDate is mandatory", cmd_name);
833  }
834 
835  if (_debug) {
836  printf("domain to renew: [%s]\n", cmd->get_name().c_str());
837  printf(" curExpDate : [%s]\n", cmd->get_curExpDate().c_str());
838  if (cmd->get_period().time != 0 || cmd->get_period().unit != "") {
839  printf(" period : [%d %s]\n", cmd->get_period().time,
840  cmd->get_period().unit.c_str());
841  }
842  } //_debug
843 
844  if (process_action(act) != 0) {
845  return -1;
846  }
847 
848  return 0;
849  }
850 
852 
856  int cmd_domain_update(vector<string> &args)
857  {
858 #if USE_BR_DOMAINS
859  BrDomainUpdate act;
860  BrDomainUpdateCmd *cmd = act.get_command();
861 #else
862  DomainUpdate act;
863  DomainUpdateCmd *cmd = act.get_command();
864 #endif //USE_BR_DOMAINS
865  string cmd_name = "update";
866 
867  cmd->set_secDnsVersion(_serverSecDnsVersion);
868 
869  if (args.empty()) {
870  return cmd_domain_help("domain name missing", cmd_name);
871  }
872  // domain name MUST be the first attribute
873  cmd->set_name(args[0]);
874  args.erase(args.begin());
875 
876  while (!args.empty()) {
877  if (args[0] == "-add-ns") {
878  //nameserver to add
879  NameServer ns;
880  if (SheppObjSet::nameServer(ns, args) != 0) {
881  return cmd_domain_help("invalid nameserver to add", cmd_name);
882  }
883  cmd->insert_nameserver_add(ns);
884  } else if (args[0] == "-rem-ns") {
885  //nameserver to remove
886  NameServer ns;
887  if (SheppObjSet::nameServer(ns, args) != 0) {
888  return cmd_domain_help("invalid nameserver to remove", cmd_name);
889  }
890  cmd->insert_nameserver_rem(ns);
891  } else if (args[0] == "-add-contact") {
892  //contact to add
893  args.erase(args.begin());
894  if (args.empty()) {
895  return cmd_domain_help("add-contact parameter missing", cmd_name);
896  }
897 
898  string type;
899  string value;
900  if (SheppStrUtil::split(args[0], type, value, "=", false) != 0) {
901  return cmd_domain_help("invalid contact to add", cmd_name);
902  }
903 
904  cmd->insert_contact_add(type, value);
905  args.erase(args.begin());
906 
907  } else if (args[0] == "-rem-contact") {
908  //contact to remove
909  args.erase(args.begin());
910  if (args.empty()) {
911  return cmd_domain_help("rem-contact parameter missing", cmd_name);
912  }
913 
914  string type;
915  string value;
916  if (SheppStrUtil::split(args[0], type, value, "=", false) != 0) {
917  return cmd_domain_help("invalid contact to remove", cmd_name);
918  }
919 
920  cmd->insert_contact_rem(type, value);
921  args.erase(args.begin());
922 
923  } else if (args[0] == "-add-status") {
924  //status to add
925  args.erase(args.begin());
926  if (args.empty()) {
927  return cmd_domain_help("add-status parameter missing", cmd_name);
928  }
929 
931  if (SheppObjSet::status(st, args) != 0) {
932  return cmd_domain_help("invalid status to add", cmd_name);
933  }
934  cmd->insert_status_add(st);
935 
936  } else if (args[0] == "-rem-status") {
937  //status to remove
938  args.erase(args.begin());
939  if (args.empty()) {
940  return cmd_domain_help("rem-status parameter missing", cmd_name);
941  }
942 
944  st.s = args[0];
945  args.erase(args.begin());
946 
947  cmd->insert_status_rem(st);
948 
949  } else if (args[0] == "-max-sig-life") {
950  args.erase(args.begin());
951  if (args.empty()) {
952  return cmd_domain_help("maxSigLife parameter missing", cmd_name);
953  }
954  cmd->set_max_sig_life(atoi(args[0].c_str()));
955  args.erase(args.begin());
956  } else if (args[0] == "-add-dnskey") {
957  //DNSSEC data (RFC 5910)
958  KeyData dnskey;
959  string error_msg;
960  if (SheppObjSet::keyData(dnskey, args, error_msg) != 0) {
961  return cmd_domain_help(error_msg, cmd_name);
962  }
963  cmd->insert_dnskey_add(dnskey);
964  } else if (args[0] == "-rem-dnskey") {
965  //DNSSEC data (RFC 5910)
966  KeyData dnskey;
967  string error_msg;
968  if (SheppObjSet::keyData(dnskey, args, error_msg) != 0) {
969  return cmd_domain_help(error_msg, cmd_name);
970  }
971  cmd->insert_dnskey_rem(dnskey);
972  } else if (args[0] == "-remove-all-secdns") {
973  args.erase(args.begin());
974  cmd->setRemoveAll(true);
975  } else if (args[0] == "-add-ds") {
976  //DS to add
977  DSInfo ds;
978  string error_msg;
979  if (SheppObjSet::dsInfo(ds, args, error_msg) != 0) {
980  return cmd_domain_help(error_msg, cmd_name);
981  }
982  cmd->insert_ds_add(ds);
983  } else if (args[0] == "-rem-ds") {
984  //DS to remove
985  DSInfo ds;
986  string error_msg;
987  if (SheppObjSet::dsInfo(ds, args, error_msg) != 0) {
988  return cmd_domain_help(error_msg, cmd_name);
989  }
990  cmd->insert_ds_rem_1_1(ds);
991  } else if (args[0] == "-rem-ds-1.0") {
992  //DS to remove (RFC4310 - DEPRECATED!)
993  args.erase(args.begin());
994  if (args.empty()) {
995  return cmd_domain_help("keytag parameter missing", cmd_name);
996  }
997  cmd->insert_ds_rem(atoi(args[0].c_str()));
998  } else if (args[0] == "-chg-ds") {
999  //DS to change
1000  DSInfo ds;
1001  string error_msg;
1002  if (SheppObjSet::dsInfo(ds, args, error_msg) != 0) {
1003  return cmd_domain_help(error_msg, cmd_name);
1004  }
1005  cmd->insert_ds_chg(ds);
1006  } else if (args[0] == "-secDNS-urgent") {
1007  cmd->setUrgentFlag(true);
1008  args.erase(args.begin());
1009  } else if (args[0] == "-r") {
1010  //registrant
1011  args.erase(args.begin());
1012  if (args.empty()) {
1013  return cmd_domain_help("registrant parameter missing", cmd_name);
1014  }
1015  cmd->set_registrant(args[0]);
1016  args.erase(args.begin());
1017  } else if (args[0] == "-auth") {
1018  //authInfo
1019  AuthInfo auth;
1020  if (SheppObjSet::authInfo(auth, args) != 0) {
1021  return cmd_domain_help("invalid auth", cmd_name);
1022  }
1023 
1024  // roid not allowed in update command
1025  if (auth.get_roid_f() == true) {
1026  return cmd_domain_help("invalid auth", cmd_name);
1027  }
1028 
1029  cmd->set_authInfo(auth);
1030 #if USE_BR_DOMAINS
1031  } else if (args[0] == "-t") {
1032  // ticketNumber
1033  args.erase(args.begin());
1034  if (args.empty()) {
1035  return cmd_domain_help("ticket number parameter missing", cmd_name);
1036  }
1037  if (atoi(args[0].c_str()) <= 0) {
1038  return cmd_domain_help("ticket parameter must be a positive integer",
1039  cmd_name);
1040  }
1041  cmd->set_ticketNumber(atoi(args[0].c_str()));
1042  args.erase(args.begin());
1043  } else if (args[0] == "-rpflags") {
1044  //releaseProcessFlags
1045  args.erase(args.begin());
1046  if (args.empty()) {
1047  return cmd_domain_help("rpflags parameter missing", cmd_name);
1048  }
1049  ReleaseProcessFlags rpf;
1050  string flag1;
1051  string flag2;
1052  string flag3;
1053 
1054  if (SheppStrUtil::split(args[0], flag1, flag2, ":", false) != 0) {
1055  return cmd_domain_help("invalid rpflags", cmd_name);
1056  }
1057 
1058  if (SheppStrUtil::split(flag2, flag2, flag3, ":", false) != 0) {
1059  return cmd_domain_help("invalid rpflags", cmd_name);
1060  }
1061 
1062  if (flag1 == "0" || flag1 == "1") {
1063  rpf.flag1 = atoi(flag1.c_str());
1064  } else if (flag1 != "-1") {
1065  return cmd_domain_help("rpflags invalid parameter. "
1066  "Expected '-1', '0' or '1'.", cmd_name);
1067  }
1068  if (flag2 == "0" || flag2 == "1") {
1069  rpf.flag2 = atoi(flag2.c_str());
1070  } else if (flag2 != "-1") {
1071  return cmd_domain_help("rpflags invalid parameter. "
1072  "Expected '-1', '0' or '1'.", cmd_name);
1073  }
1074  if (flag3 == "0" || flag3 == "1") {
1075  rpf.flag3 = atoi(flag3.c_str());
1076  } else if (flag3 != "-1") {
1077  return cmd_domain_help("rpflags invalid parameter. "
1078  "Expected '-1', '0' or '1'.", cmd_name);
1079  }
1080 
1081  cmd->set_releaseProcessFlags(rpf);
1082  args.erase(args.begin());
1083  } else if (args[0] == "-auto-renew") {
1084  //auto-renew
1085  args.erase(args.begin());
1086  if (args.empty()) {
1087  return cmd_domain_help("auto-renew parameter missing", cmd_name);
1088  }
1089  if (args[0] == "on") {
1090  cmd->set_auto_renew(1);
1091  } else if (args[0] == "off") {
1092  cmd->set_auto_renew(0);
1093  } else {
1094  return cmd_domain_help("invalid auto-renew", cmd_name);
1095  }
1096  args.erase(args.begin());
1097  } else if (args[0] == "-publication-status") {
1098  // domain status
1099  args.erase(args.begin());
1100  if (args.empty()) {
1101  return cmd_domain_help("publication status parameter missing", cmd_name);
1102  }
1103  if (args[0] == "published") {
1104  cmd->set_publication_status(BrDomainUpdateCmd::PUBLISHED);
1105  } else if (args[0] == "onHold") {
1106  cmd->set_publication_status(BrDomainUpdateCmd::ONHOLD);
1107  } else {
1108  return cmd_domain_help("invalid publication status", cmd_name);
1109  }
1110  args.erase(args.begin());
1111  } else if (args[0] == "-o") {
1112  // organization
1113  args.erase(args.begin());
1114  if (args.empty()) {
1115  return cmd_domain_help("organization parameter missing", cmd_name);
1116  }
1117  cmd->set_organization(args[0]);
1118  args.erase(args.begin());
1119 #endif //USE_BR_DOMAINS
1120  } else if (args[0] == "-rgp") {
1121  RGPRestore rgp_restore;
1122  string error_msg;
1123  if (SheppObjSet::rgpRestore(args, rgp_restore, error_msg) != 0) {
1124  return cmd_domain_help(error_msg, cmd_name);
1125  }
1126  cmd->set_rgp_restore(rgp_restore);
1127  } else if (args[0] == "-launch") {
1128  args.erase(args.begin());
1129 
1130  if (args.empty()) {
1131  return cmd_domain_help("phase missing", cmd_name);
1132  }
1133 
1134  string phaseStr, name;
1135  SheppStrUtil::split(args[0], phaseStr, name, ":", true);
1136 
1137  LaunchPhase::Value phase = LaunchPhase::fromStr(phaseStr);
1138  if (phase == LaunchPhase::NONE) {
1139  return cmd_domain_help("invalid phase", cmd_name);
1140  }
1141 
1142  LaunchPhase launchPhase;
1143  launchPhase.set_phase(phase);
1144  launchPhase.set_name(name);
1145 
1146  args.erase(args.begin());
1147 
1148  if (args.empty()) {
1149  return cmd_domain_help("application id missing", cmd_name);
1150  }
1151 
1152  string applicationId = args[0];
1153 
1154  LaunchUpdateCmd launch;
1155  launch.set_phase(launchPhase);
1156  launch.set_applicationId(applicationId);
1157  cmd->set_launch(launch);
1158 
1159  args.erase(args.begin());
1160  } else {
1161  return cmd_domain_help("invalid syntax near \"" + args[0] + "\"",
1162  cmd_name);
1163  }
1164  }
1165 
1166 #if USE_BR_DOMAINS
1167  bool brdomain_rpf_update = false;
1168  //if it has brdomain attributes set it MUST have ticketNumber also
1169  if (cmd->get_releaseProcessFlags().flag1 != -1 ||
1170  cmd->get_releaseProcessFlags().flag2 != -1 ||
1171  cmd->get_releaseProcessFlags().flag3 != -1) {
1172  brdomain_rpf_update = true;
1173  }
1174 
1175  if (brdomain_rpf_update && cmd->get_ticketNumber() == 0) {
1176  return cmd_domain_help("BrDomain extension rpf updates "
1177  "MUST contain ticketNumber", cmd_name);
1178  }
1179 #endif //USE_BR_DOMAINS
1180 
1181  if (cmd->get_nameserver_add().empty() &&
1182  cmd->get_nameserver_rem().empty() &&
1183  cmd->has_secdns_extension() == false &&
1184  cmd->get_contact_add().empty() &&
1185  cmd->get_contact_rem().empty() &&
1186  cmd->get_status_add().empty() &&
1187  cmd->get_status_rem().empty() &&
1188  cmd->get_registrant() == "" &&
1189  cmd->get_authInfo().get_pw() == ""
1190 #if USE_BR_DOMAINS
1191  && !brdomain_rpf_update
1192  && cmd->get_auto_renew() == -1
1193  && cmd->get_publication_status() == BrDomainUpdateCmd::UNDEFINED
1194  && cmd->get_organization().empty() == true
1195 #endif //USE_BR_DOMAINS
1196  && cmd->get_rgp_restore().get_operation() == RGPRestore::Operation::NONE
1197  ) {
1198  return cmd_domain_help("you didn't set a thing", cmd_name);
1199  }
1200 
1201  if (_debug) {
1202  printf("updating domain: %s\n", cmd->get_name().c_str());
1203 
1204  vector<NameServer> nss = cmd->get_nameserver_add();
1205  vector<NameServer>::const_iterator nsit;
1206  if (!nss.empty()) {
1207  printf(" nameservers to add:\n");
1208  }
1209  for (nsit = nss.begin(); nsit != nss.end(); nsit++) {
1210  SheppPrint::nameserver(*nsit);
1211  }
1212 
1213  nss = cmd->get_nameserver_rem();
1214  if (!nss.empty()) {
1215  printf(" nameservers to remove:\n");
1216  }
1217  for (nsit = nss.begin(); nsit != nss.end(); nsit++) {
1218  SheppPrint::nameserver(*nsit);
1219  }
1220 
1221  if (cmd->get_registrant() != "") {
1222  printf(" registrant: %s\n", cmd->get_registrant().c_str());
1223  }
1224 
1225  map< string, string, less<string> > contacts = cmd->get_contact_add();
1226  map< string, string, less<string> >::const_iterator cit;
1227  if (!contacts.empty()) {
1228  printf(" contacts to add:\n");
1229  }
1230  for (cit = contacts.begin(); cit != contacts.end(); cit++) {
1231  printf(" contact %s: %s\n", (*cit).first.c_str(),
1232  (*cit).second.c_str());
1233  }
1234 
1235  contacts = cmd->get_contact_rem();
1236  if (!contacts.empty()) {
1237  printf(" contacts to remove:\n");
1238  }
1239  for (cit = contacts.begin(); cit != contacts.end(); cit++) {
1240  printf(" contact %s: %s\n", (*cit).first.c_str(),
1241  (*cit).second.c_str());
1242  }
1243 
1244  set<DomainUpdateCmd::Status> statuses = cmd->get_status_add();
1245  set<DomainUpdateCmd::Status>::const_iterator stit;
1246  if (!statuses.empty()) {
1247  printf(" status to add:\n");
1248  }
1249  for (stit = statuses.begin(); stit != statuses.end(); stit++) {
1250  printf(" s : [%s]\n", (*stit).s.c_str());
1251  printf(" lang: [%s]\n", (*stit).lang.c_str());
1252  printf(" msg : [%s]\n", (*stit).msg.c_str());
1253  }
1254  statuses = cmd->get_status_rem();
1255  if (!statuses.empty()) {
1256  printf(" status to remove:\n");
1257  }
1258  for (stit = statuses.begin(); stit != statuses.end(); stit++) {
1259  printf(" s : [%s]\n", (*stit).s.c_str());
1260  printf(" lang: [%s]\n", (*stit).lang.c_str());
1261  printf(" msg : [%s]\n", (*stit).msg.c_str());
1262  }
1263 
1265 
1266 #if USE_BR_DOMAINS
1267  if (cmd->get_ticketNumber() != 0) {
1268  printf(" ticketNumber: [%d]\n", cmd->get_ticketNumber());
1269  }
1270 
1271  if (cmd->get_releaseProcessFlags().flag1 != -1 ||
1272  cmd->get_releaseProcessFlags().flag2 != -1 ||
1273  cmd->get_releaseProcessFlags().flag3 != -1) {
1274  printf(" releaseProcessFlags: %d, %d, %d\n",
1275  cmd->get_releaseProcessFlags().flag1,
1276  cmd->get_releaseProcessFlags().flag2,
1277  cmd->get_releaseProcessFlags().flag3);
1278  }
1279 
1280  printf(" auto-renew: %d\n", cmd->get_auto_renew());
1281 #endif //USE_BR_DOMAINS
1282  } // _debug
1283 
1284  if (process_action(act) != 0) {
1285  return -1;
1286  }
1287 
1288  return 0;
1289  }
1290 
1292 
1296  int cmd_domain(vector<string> &args)
1297  {
1298  // domain command processing
1299  if (!args.empty() && !(args[0] == "help")) {
1300  if (args[0] == "check") {
1301  args.erase(args.begin());
1302  return cmd_domain_check(args);
1303  } else if (args[0] == "info") {
1304  args.erase(args.begin());
1305  return cmd_domain_info(args);
1306  } else if (args[0] == "transfer") {
1307  args.erase(args.begin());
1308  return cmd_domain_transfer(args);
1309  } else if (args[0] == "create") {
1310  args.erase(args.begin());
1311  return cmd_domain_create(args);
1312  } else if (args[0] == "delete") {
1313  args.erase(args.begin());
1314  return cmd_domain_delete(args);
1315  } else if (args[0] == "renew") {
1316  args.erase(args.begin());
1317  return cmd_domain_renew(args);
1318  } else if (args[0] == "update") {
1319  args.erase(args.begin());
1320  return cmd_domain_update(args);
1321  } else {
1322  return cmd_domain_help("invalid command: domain " + args[0]);
1323  }
1324  }
1325 
1326  return cmd_domain_help("");
1327  }
1328 
1329 #endif //__DOMAIN_FUNCTIONS_H__
void set_name(const string &name)
Sets domain name.
Definition: DomainRenewCmd.H:42
BrDomainInfoCmd * get_command()
Returns raw pointer to the command.
Definition: BrDomainInfo.H:40
Definition: RegistrationPeriod.H:17
void set_phase(const Value phase)
Sets the launch phase.
Definition: Launch.H:215
static int claimsNotice(ClaimsNotice &notice, vector< string > &words, string &error)
Fill a claims notice object.
Definition: SheppObjSet.H:638
void set_name(const string &name)
Sets domain name.
Definition: DomainTransferCmd.H:50
set< string > get_domains_list() const
Returns domains list.
Definition: DomainCheckCmd.H:45
void set_name(const string &name)
Sets domain name.
Definition: DomainUpdateCmd.H:57
DomainDeleteCmd * get_command()
Returns raw pointer to the command.
Definition: DomainDelete.H:57
string get_name() const
Returns domain name.
Definition: DomainCreateCmd.H:53
DomainCreateCmd * get_command()
Returns raw pointer to the command.
Definition: DomainCreate.H:56
EPP DomainInfo Class.
Definition: DomainInfo.H:23
void set_name(const string &name)
Sets domain name.
Definition: DomainInfoCmd.H:39
EPP EncodedSignedMark Class.
Definition: Launch.H:72
Type::Value get_type() const
Returns the expected type of object.
Definition: LaunchCheckCmd.H:86
EPP BrDomainInfoCmd extension Class.
Definition: BrDomainInfoCmd.H:15
void set_operation(const TransferOperation::Value operation)
Sets transfer operation to be performed.
Definition: DomainTransferCmd.H:38
EPP Launch Phase Class.
Definition: Launch.H:121
static Value fromStr(const string &value)
Convert text type to value.
Definition: LaunchCheckCmd.H:57
void set_type(const Type::Value type)
Sets the expected type of object.
Definition: LaunchCheckCmd.H:80
EPP DomainDelete Class.
Operation::Value get_operation() const
Returns the operation.
Definition: RGPRestore.H:356
static int split(string input, string &first, string &second, string splitter, bool relaxed=false)
Definition: SheppStrUtil.H:120
void insert_dnskey_rem(const KeyData &keydata)
Inserts one DNSKEY into the DNSKEY removal list.
Definition: DomainUpdateCmd.H:277
EPP BrDomainRenew extension Class.
Definition: BrDomainRenew.H:17
AuthInfo get_authInfo() const
Returns authorization information.
Definition: DomainCreateCmd.H:128
string get_registrant() const
Returns registrant.
Definition: DomainUpdateCmd.H:183
BrDomainUpdateCmd * get_command()
Returns raw pointer to the command.
Definition: BrDomainUpdate.H:41
void set_name(const string &name)
Sets domain name.
Definition: DomainDeleteCmd.H:37
void set_rgp_restore(const RGPRestore &rgp_restore)
Sets RFC3915 RGP restore structure.
Definition: DomainUpdateCmd.H:406
AuthInfo get_authInfo() const
Returns authorization information.
Definition: DomainUpdateCmd.H:216
EPP DomainCheck Class.
EPP DomainDelete Class.
Definition: DomainDelete.H:23
EPP DomainTransferCmd Class.
Definition: DomainTransferCmd.H:23
map< string, string, less< string > > get_contacts() const
Returns map of other contacts.
Definition: DomainCreateCmd.H:113
Value
Possible operation values.
Definition: CommonData.H:885
EPP DomainRenew Class.
EPP BrDomainCreate extension Class.
Definition: BrDomainCreate.H:17
EPP DomainInfo Class.
static string & trim(string &s)
Trim from both ends.
EPP BrDomainInfo extension Class.
Definition: BrDomainInfo.H:17
void set_secDnsVersion(string secDnsVersion)
Sets secDNS extension version.
Definition: DomainUpdateCmd.H:223
void insert_contact(const string &type, const string &identification)
Inserts a contact in the map of other contacts.
Definition: DomainCreateCmd.H:104
string get_name() const
Returns domain name.
Definition: DomainDeleteCmd.H:43
static void authInfo(AuthInfo auth)
prints an AuthInfo object
Definition: SheppPrint.H:21
Definition: CommonData.H:183
EPP LaunchCreateCmd Class.
Definition: LaunchCreateCmd.H:20
static int keyData(KeyData &dnskey, vector< string > &words, string &error_msg)
fills a KeyData based on input command line
Definition: SheppObjSet.H:321
DomainRenewCmd * get_command()
Returns raw pointer to the command.
Definition: DomainRenew.H:57
AuthInfo get_authInfo() const
Returns authorization information.
Definition: DomainInfoCmd.H:77
bool has_secdns_extension() const
Check if there is secDNS extension.
Definition: DomainUpdateCmd.H:441
EPP BrDomainCheck extension Class.
void set_period(const int time, const string &unit)
Sets domain registration period.
Definition: DomainCreateCmd.H:60
RegistrationPeriod get_period() const
Returns domain registration period.
Definition: DomainCreateCmd.H:70
EPP BrDomainCreateCmd extension Class.
Definition: BrDomainCreateCmd.H:16
void set_launch(const LaunchCheckCmd &launch)
Sets the launch.
Definition: DomainCheckCmd.H:51
void insert_dnskey_add(const KeyData &keydata)
Inserts one DNSKEY into the DNSKEY addition list.
Definition: DomainUpdateCmd.H:259
void insert_domain(const string &domain)
Add a domain name to the list.
Definition: DomainCheckCmd.H:39
void set_applicationId(const string &applicationId)
Definition: LaunchUpdateCmd.H:46
void set_data(const string &data)
Sets the signed mark encoded data.
Definition: Launch.H:97
int cmd_domain_create(vector< string > &args)
domain create command function
Definition: DomainFunctions.H:410
void setRemoveAll(const bool removeAll)
Sets RFC5910 alternative "remove all" attribute for domain:update.
Definition: DomainUpdateCmd.H:385
void set_phase(const LaunchPhase &phase)
Sets the phase of the launch.
Definition: LaunchCreateCmd.H:93
void set_launch(const LaunchCreateCmd &launch)
Sets the launch.
Definition: DomainCreateCmd.H:207
int cmd_domain_help(string error_msg, string specific="")
print domain command usage info
Definition: DomainFunctions.H:35
void set_authInfo(const AuthInfo &authInfo)
Sets authorization information.
Definition: DomainInfoCmd.H:68
static int status(DomainUpdateCmd::Status &st, vector< string > &words)
fills a Status based on input command line
Definition: SheppObjSet.H:122
void add_keyData(const KeyData &dnskey_data)
Adds DNSKEY information.
Definition: DomainCreateCmd.H:171
Definition: BrDomainCommon.H:26
void set_applicationId(const string &applicationId)
Definition: LaunchDeleteCmd.H:46
Value
Possible phase values.
Definition: Launch.H:125
set< struct Status > get_status_rem() const
Returns set of domain status_rem.
Definition: DomainUpdateCmd.H:167
EPP DomainTransfer Class.
void insert_contact_add(const string &type, const string &identification)
Inserts a contact_add in the map of contacts.
Definition: DomainUpdateCmd.H:106
void set_authInfo(const AuthInfo &authInfo)
Sets authorization information.
Definition: DomainUpdateCmd.H:207
vector< struct NameServer > get_nameserver_rem() const
Returns a list of nameserver_rem.
Definition: DomainUpdateCmd.H:96
EPP DomainUpdate Class.
EPP RegistrationPeriod struct.
int cmd_domain_renew(vector< string > &args)
domain renew command function
Definition: DomainFunctions.H:777
void insert_ds_rem_1_1(const DSInfo &ds_info)
Inserts one ds into the ds removal list.
Definition: DomainUpdateCmd.H:313
DSInfo Class.
Definition: DSInfo.H:16
int cmd_domain_info(vector< string > &args)
domain info command function
Definition: DomainFunctions.H:247
RegistrationPeriod get_period() const
Returns domain registration period.
Definition: DomainRenewCmd.H:87
int cmd_domain_transfer(vector< string > &args)
domain transfer command function
Definition: DomainFunctions.H:358
void set_phase(const LaunchPhase &phase)
Sets the phase of the launch.
Definition: LaunchInfoCmd.H:44
Definition: DomainUpdateCmd.H:36
EPP BrDomainCreate extension Class.
string get_curExpDate() const
Returns date of the next renewal.
Definition: DomainRenewCmd.H:60
EPP Notice Class.
Definition: ClaimsNotice.H:13
string get_name() const
Returns domain name.
Definition: DomainUpdateCmd.H:63
string get_registrant() const
Returns registrant.
Definition: DomainCreateCmd.H:97
map< string, string, less< string > > get_contact_add() const
Returns map of contacts.
Definition: DomainUpdateCmd.H:115
vector< struct NameServer > get_nameservers() const
Returns a list of nameservers.
Definition: DomainCreateCmd.H:85
EPP DomainCheckCmd Class.
Definition: DomainCheckCmd.H:24
EPP BrDomainCheck extension Class.
Definition: BrDomainCheck.H:17
void insert_nameserver_add(const struct NameServer &nameserver_add)
Inserts a nameserver_add to the list of nameservers.
Definition: DomainUpdateCmd.H:69
void insert_ds_chg(const DSInfo &ds_info)
Inserts one ds into the ds change list.
Definition: DomainUpdateCmd.H:349
bool get_roid_f() const
Returns the roid change flag.
Definition: CommonData.H:121
int process_action(Action &act)
Send and EPP Action.
Definition: SheppCommandFunctions.H:871
BrDomainCreateCmd * get_command()
Returns raw pointer to the command.
Definition: BrDomainCreate.H:41
Definition: KeyData.H:15
void insert_ds_rem(const unsigned int &keyTag)
Inserts one ds into the ds removal list (RFC4310 - DEPRECATED!)
Definition: DomainUpdateCmd.H:322
void set_notice(const ClaimsNotice &notice)
Sets the notice for Claims period.
Definition: LaunchCreateCmd.H:105
void set_period(const int time, const string &unit)
Sets domain renewal period.
Definition: DomainRenewCmd.H:67
EPP DomainDeleteCmd Class.
Definition: DomainDeleteCmd.H:22
void set_curExpDate(const string &curExpDate)
Definition: DomainRenewCmd.H:54
EPP DomainCreate Class.
Definition: DomainCreate.H:23
string get_name() const
Returns domain name.
Definition: DomainRenewCmd.H:48
int cmd_domain_update(vector< string > &args)
domain update command function
Definition: DomainFunctions.H:856
EPP DomainRenewCmd Class.
Definition: DomainRenewCmd.H:27
void set_name(const string &name)
Sets domain name.
Definition: DomainCreateCmd.H:47
static Value fromStr(const string operationStr)
Definition: CommonData.H:925
void set_registrant(const string &registrant)
Sets registrant.
Definition: DomainCreateCmd.H:91
void set_phase(const LaunchPhase &phase)
Sets the phase of the launch.
Definition: LaunchDeleteCmd.H:32
void setUrgentFlag(const bool urgentFlag)
Sets RFC4310 optional "urgent" attribute for domain:update.
Definition: DomainUpdateCmd.H:367
void set_encodedSignedMarks(const list< EncodedSignedMark > &encodedSignedMarks)
Sets the encoded signed mark list.
Definition: LaunchCreateCmd.H:144
int cmd_domain_delete(vector< string > &args)
domain check delete function
Definition: DomainFunctions.H:706
EPP LaunchInfoCmd Class.
Definition: LaunchInfoCmd.H:19
BrDomainCheckCmd * get_command()
Returns raw pointer to the command.
Definition: BrDomainCheck.H:40
EPP BrDomainRenew extension Class.
void set_launch(const LaunchDeleteCmd &launch)
Sets the launch.
Definition: DomainDeleteCmd.H:49
EPP DomainUpdateCmd Class.
Definition: DomainUpdateCmd.H:32
void insert_nameserver_rem(const struct NameServer &nameserver_rem)
Inserts a nameserver_rem to the list of nameservers.
Definition: DomainUpdateCmd.H:87
void set_name(const string &name)
Sets the launch phase name when the phase is CUSTOM.
Definition: Launch.H:227
DomainInfoCmd * get_command()
Returns raw pointer to the command.
Definition: DomainInfo.H:57
string get_pw() const
Returns the password.
Definition: CommonData.H:140
string get_name() const
Returns domain name.
Definition: DomainInfoCmd.H:45
void insert_ds_add(const DSInfo &ds_info)
Inserts one ds into the ds addition list.
Definition: DomainUpdateCmd.H:295
EPP DomainCreateCmd Class.
Definition: DomainCreateCmd.H:32
EPP DomainRenew Class.
Definition: DomainRenew.H:23
void set_phase(const LaunchPhase &phase)
Sets the phase of the launch.
Definition: LaunchCheckCmd.H:92
void insert_status_add(const struct Status &status_add)
Changes a status_add.
Definition: DomainUpdateCmd.H:143
void set_applicationId(const string &applicationId)
Sets the application identifier of the Launch Application.
Definition: LaunchInfoCmd.H:56
void add_dsInfo(const DSInfo &ds_info)
Adds DS information.
Definition: DomainCreateCmd.H:153
void insert_nameserver(const struct NameServer &nameserver)
Inserts a nameserver to the list of nameservers.
Definition: DomainCreateCmd.H:76
void set_max_sig_life(const unsigned int max_sig_life)
Sets the maximum signature life.
Definition: DomainUpdateCmd.H:241
RGPRestore get_rgp_restore() const
Returns RFC3915 RGP restore structure.
Definition: DomainUpdateCmd.H:415
EPP command-line shell client command functions include file.
EPP DomainCheck Class.
Definition: DomainCheck.H:23
set< struct Status > get_status_add() const
Returns set of domain status_add.
Definition: DomainUpdateCmd.H:152
void set_authInfo(const AuthInfo &authInfo)
Sets authorization information.
Definition: DomainCreateCmd.H:119
void set_includeMark(const bool includeMark)
Sets whether or not to include the mark in the response.
Definition: LaunchInfoCmd.H:32
EPP BrDomainUpdateCmd extension Class.
Definition: BrDomainUpdateCmd.H:16
void set_authInfo(const AuthInfo &authInfo)
Sets authorization information.
Definition: DomainTransferCmd.H:82
void insert_status_rem(const struct Status &status_rem)
Changes a status_rem in _status_rem.
Definition: DomainUpdateCmd.H:158
EPP DomainTransfer Class.
Definition: DomainTransfer.H:23
EPP DomainCreate Class.
void set_phase(const LaunchPhase &phase)
Sets the phase of the launch.
Definition: LaunchUpdateCmd.H:32
static Value fromStr(const string &value)
Convert text phase to value.
Definition: Launch.H:164
DomainTransferCmd * get_command()
Returns raw pointer to the command.
Definition: DomainTransfer.H:57
DomainCheckCmd * get_command()
Returns raw pointer to the command.
Definition: DomainCheck.H:57
void set_registrant(const string &registrant)
Sets registrant.
Definition: DomainUpdateCmd.H:173
void set_secDnsVersion(string secDnsVersion)
Sets secDNS extension version.
Definition: DomainCreateCmd.H:135
void set_launch(const LaunchInfoCmd &launch)
Sets the launch.
Definition: DomainInfoCmd.H:83
EPP LaunchUpdateCmd Class.
Definition: LaunchUpdateCmd.H:19
EPP LaunchCheckCmd Class.
Definition: LaunchCheckCmd.H:19
EPP DomainInfoCmd Class.
Definition: DomainInfoCmd.H:23
EPP RGPRestore Class.
Definition: RGPRestore.H:290
EPP BrDomainUpdate extension Class.
Definition: BrDomainUpdate.H:17
EPP BrDomainUpdate extension Class.
static void nameserver(NameServer ns)
prints a NameServer object
Definition: SheppPrint.H:36
vector< struct NameServer > get_nameserver_add() const
Returns a list of nameserver_add.
Definition: DomainUpdateCmd.H:78
static int nameServer(NameServer &ns, vector< string > &words)
fills a NameServer based on input command line
Definition: SheppObjSet.H:84
int cmd_domain(vector< string > &args)
main domain command
Definition: DomainFunctions.H:1296
static int dsInfo(DSInfo &ds, vector< string > &words, string &error_msg)
fills a DSInfo based on input command line
Definition: SheppObjSet.H:182
static int authInfo(AuthInfo &auth, vector< string > &words)
fills an AuthInfo based on input command line
Definition: SheppObjSet.H:54
EPP LaunchDeleteCmd Class.
Definition: LaunchDeleteCmd.H:19
EPP DomainUpdate Class.
Definition: DomainUpdate.H:23
void insert_contact_rem(const string &type, const string &identification)
Inserts a contact_rem in the map of contacts.
Definition: DomainUpdateCmd.H:125
EPP BrDomainCheckCmd extension Class.
Definition: BrDomainCheckCmd.H:15
int cmd_domain_check(vector< string > &args)
domain check command function
Definition: DomainFunctions.H:147
void set_launch(const LaunchUpdateCmd &launch)
Sets the launch.
Definition: DomainUpdateCmd.H:425
static int rgpRestore(vector< string > &words, RGPRestore &rgp_restore, string &error_msg)
fill a registry grace period structure
Definition: SheppObjSet.H:661
EPP BrDomainInfo extension Class.
AuthInfo Class.
Definition: CommonData.H:83
void set_max_sig_life(const unsigned int max_sig_life)
Sets the maximum signature life.
Definition: DomainCreateCmd.H:189
DomainUpdateCmd * get_command()
Returns raw pointer to the command.
Definition: DomainUpdate.H:56
map< string, string, less< string > > get_contact_rem() const
Returns map of contacts.
Definition: DomainUpdateCmd.H:134