1 /*
2 * Copyright (C) 2006-2021 Registro.br. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 * 1. Redistribution of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY REGISTRO.BR ``AS IS AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15 * WARRANTIE OF FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
16 * EVENT SHALL REGISTRO.BR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
18 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
19 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
20 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
21 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
22 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
23 * DAMAGE.
24 */
25 /* $Id$ */
26 /** @file DefRegFunctions.H
27 * @brief EPP Defensive Registration related functions
28 */
29
30 #ifndef __DEF_REG_FUNCTIONS_H__
31 #define __DEF_REG_FUNCTIONS_H__
32
33 #include "SheppCommandFunctions.H"
34 #include "SheppStrUtil.H"
35
36 #include "DefRegCheck.H"
37 #include "DefRegInfo.H"
38 #include "DefRegTransfer.H"
39 #include "DefRegCreate.H"
40 #include "DefRegDelete.H"
41 #include "DefRegRenew.H"
42 #include "DefRegUpdate.H"
43
44 /// print defensive registration command usage info
45 /**
46 @param error_msg error message to be printed
47 @param specific optional, choses specific sub-command
48 @return 0 if ok, -1 otherwise
49 */
50 int cmd_def_reg_help(string error_msg, string specific = "")
51 {
52 if (error_msg != "") {
53 printf("error: %s\n", error_msg.c_str());
54 }
55
56 printf("defensive registration command syntax help:\n");
57 printf("\n");
58
59 if (specific == "" || specific == "check") {
60 printf(" check <name1:level> [name2:level ... nameN:level]\n");
61 printf("\n");
62 }
63
64 if (specific == "" || specific == "info") {
65 printf(" info <roid> [-auth authInfoPw[:authInfoRoid]]\n");
66 printf("\n");
67 }
68
69 if (specific == "" || specific == "transfer") {
70 printf(" transfer <query|request> <roid> \n"
71 " [-period time:unit] [-auth authInfoPw[:authInfoRoid]]\n");
72 printf("\n");
73 }
74
75 if (specific == "" || specific == "create") {
76 printf(" create <name:level> <registrant> <adminContact>\n"
77 " <-auth authInfoPw[:authInfoRoid]>\n"
78 " [-tm trademarkId] [-tmc trademarkCountry]\n"
79 " [-tmd trademarkDate] [-period time:unit]\n");
80 printf("\n");
81 }
82
83 if (specific == "" || specific == "delete") {
84 printf(" delete <roid>\n");
85 printf("\n");
86 }
87
88 if (specific == "" || specific == "renew") {
89 printf(" renew <roid> <-expdate curExpDate> [-period time:unit]\n");
90 printf("\n");
91 }
92
93 if (specific == "" || specific == "update") {
94 printf(" update <roid>\n"
95 " [-add-status status:lang:\"description\" ...]\n"
96 " [-rem-status status ...]\n"
97 " [-r registrant] [-a adminContact]\n"
98 " [-tm trademarkId] [-tmc trademarkCountry]\n"
99 " [-tmd trademarkDate] [-auth authInfoPw[:authInfoRoid]]\n");
100 printf("\n");
101 }
102
103 if (error_msg != "") {
104 return -1;
105 }
106
107 return 0;
108 }
109
110 /// defensive registration check command function
111 /**
112 @param args vector with command-line arguments
113 @return 0 if ok, -1 otherwise
114 */
cmd_def_reg_check(vector<string> & args)115 int cmd_def_reg_check(vector<string> &args)
116 {
117 DefRegCheck act;
118 DefRegCheckCmd *cmd = act.get_command();
119 string cmd_name = "check";
120
121 while (!args.empty()) {
122 string nameStr;
123 string levelStr;
124
125 if (SheppStrUtil::split(args[0], nameStr, levelStr, ":") != 0) {
126 return cmd_def_reg_help("invalid syntax near \"" + args[0] + "\"", cmd_name);
127 }
128
129 DefRegLevel::Value level = DefRegLevel::fromStr(levelStr);
130 if (level == DefRegLevel::NONE) {
131 return cmd_def_reg_help("invalid level \"" + levelStr + "\"");
132 }
133
134 DefRegName name;
135 name.set_name(nameStr);
136 name.set_level(level);
137
138 cmd->insert_name(name);
139 args.erase(args.begin());
140 }
141
142 if (cmd->get_name_list().empty()) {
143 return cmd_def_reg_help("no names specified", cmd_name);
144 }
145
146 if (_debug) {
147 set<DefRegName> names = cmd->get_name_list();
148 set<DefRegName>::const_iterator it;
149 printf("names to be checked:\n");
150 for (it = names.begin(); it != names.end(); it++) {
151 printf(" [%s:%s]\n",
152 it->get_name().c_str(),
153 DefRegLevel::toStr(it->get_level()).c_str());
154 }
155 }
156
157 if (process_action(act) != 0) {
158 return -1;
159 }
160
161 return 0;
162 }
163
164 /// defensive registration info command function
165 /**
166 @param args vector with command-line arguments
167 @return 0 if ok, -1 otherwise
168 */
cmd_def_reg_info(vector<string> & args)169 int cmd_def_reg_info(vector<string> &args)
170 {
171 DefRegInfo act;
172 DefRegInfoCmd *cmd = act.get_command();
173 string cmd_name = "info";
174
175 if (args.empty()) {
176 return cmd_def_reg_help("no roid specified", cmd_name);
177 }
178
179 cmd->set_roid(args[0]);
180 args.erase(args.begin());
181
182 while (!args.empty()) {
183 if (args[0] == "-auth") {
184 // set authInfo
185 AuthInfo auth;
186 if (SheppObjSet::authInfo(auth, args) != 0) {
187 return cmd_def_reg_help("invalid auth", cmd_name);
188 }
189 cmd->set_authInfo(auth);
190 } else {
191 return cmd_def_reg_help("invalid syntax near \"" + args[0] + "\"",
192 cmd_name);
193 }
194 }
195
196 if (_debug) {
197 printf("roid to get info: [%s]\n", cmd->get_roid().c_str());
198 SheppPrint::authInfo(cmd->get_authInfo());
199 } // _debug
200
201 if (process_action(act) != 0) {
202 return -1;
203 }
204
205 return 0;
206 }
207
208 /// defensive registration transfer command function
209 /**
210 @param args vector with command-line arguments
211 @return 0 if ok, -1 otherwise
212 */
cmd_def_reg_transfer(vector<string> & args)213 int cmd_def_reg_transfer(vector<string> &args)
214 {
215 DefRegTransfer act;
216 DefRegTransferCmd *cmd = act.get_command();
217 string cmd_name = "transfer";
218
219 if (args.empty()) {
220 return cmd_def_reg_help("no operation specified", cmd_name);
221 }
222
223 TransferOperation::Value op = TransferOperation::fromStr(args[0]);
224 if (op == TransferOperation::NONE) {
225 return cmd_def_reg_help("invalid operation", cmd_name);
226 }
227
228 cmd->set_operation(op);
229 args.erase(args.begin());
230
231 if (args.empty()) {
232 return cmd_def_reg_help("no roid specified", cmd_name);
233 }
234
235 cmd->set_roid(args[0]);
236 args.erase(args.begin());
237
238 while (!args.empty()) {
239 if (args[0] == "-period") {
240 // period
241 args.erase(args.begin());
242 if (args.empty()) {
243 return cmd_domain_help("period parameter missing", cmd_name);
244 }
245
246 string time;
247 string unit;
248 if (SheppStrUtil::split(args[0], time, unit, ":", false) != 0) {
249 return cmd_domain_help("invalid period", cmd_name);
250 }
251
252 cmd->set_period(atoi(time.c_str()), unit);
253 args.erase(args.begin());
254 } else if (args[0] == "-auth") {
255 // set authInfo
256 AuthInfo auth;
257 if (SheppObjSet::authInfo(auth, args) != 0) {
258 return cmd_def_reg_help("invalid auth", cmd_name);
259 }
260 cmd->set_authInfo(auth);
261 } else {
262 return cmd_def_reg_help("invalid syntax near \"" + args[0] + "\"",
263 cmd_name);
264 }
265 }
266
267 if (_debug) {
268 printf("defensive registration to transfer: [%s]\n", cmd->get_roid().c_str());
269 SheppPrint::authInfo(cmd->get_authInfo());
270 } // _debug
271
272 if (process_action(act) != 0) {
273 return -1;
274 }
275
276 return 0;
277 }
278
279 /// defensive registration create command function
280 /**
281 @param args vector with command-line arguments
282 @return 0 if ok, -1 otherwise
283 */
cmd_def_reg_create(vector<string> & args)284 int cmd_def_reg_create(vector<string> &args)
285 {
286 DefRegCreate act;
287 DefRegCreateCmd *cmd = act.get_command();
288 string cmd_name = "create";
289
290 if (args.empty()) {
291 return cmd_def_reg_help("no name specified", cmd_name);
292 }
293
294 string nameStr;
295 string levelStr;
296
297 if (SheppStrUtil::split(args[0], nameStr, levelStr, ":") != 0) {
298 return cmd_def_reg_help("invalid syntax near \"" + args[0] + "\"", cmd_name);
299 }
300
301 DefRegLevel::Value level = DefRegLevel::fromStr(levelStr);
302 if (level == DefRegLevel::NONE) {
303 return cmd_def_reg_help("invalid level \"" + levelStr + "\"");
304 }
305
306 DefRegName name;
307 name.set_name(nameStr);
308 name.set_level(level);
309
310 cmd->set_name(name);
311 args.erase(args.begin());
312
313 if (args.empty()) {
314 return cmd_def_reg_help("no registrant specified", cmd_name);
315 }
316
317 cmd->set_registrant(args[0]);
318 args.erase(args.begin());
319
320 if (args.empty()) {
321 return cmd_def_reg_help("no admin contact specified", cmd_name);
322 }
323
324 cmd->set_admin_contact(args[0]);
325 args.erase(args.begin());
326
327 while (!args.empty()) {
328 if (args[0] == "-tm") {
329 //trademark
330 args.erase(args.begin());
331 if (args.empty()) {
332 return cmd_domain_help("trademark parameter missing", cmd_name);
333 }
334
335 cmd->set_trademark_id(args[0]);
336 args.erase(args.begin());
337
338 } else if (args[0] == "-tmc") {
339 //trademark country
340 args.erase(args.begin());
341 if (args.empty()) {
342 return cmd_domain_help("trademark country parameter missing", cmd_name);
343 }
344
345 cmd->set_trademark_country(args[0]);
346 args.erase(args.begin());
347
348 } else if (args[0] == "-tmd") {
349 //trademark date
350 args.erase(args.begin());
351 if (args.empty()) {
352 return cmd_domain_help("trademark date parameter missing", cmd_name);
353 }
354
355 cmd->set_trademark_date(args[0]);
356 args.erase(args.begin());
357
358 } else if (args[0] == "-period") {
359 //registration period
360 args.erase(args.begin());
361 if (args.empty()) {
362 return cmd_domain_help("period parameter missing", cmd_name);
363 }
364
365 string time;
366 string unit;
367 if (SheppStrUtil::split(args[0], time, unit, ":", false) != 0) {
368 return cmd_domain_help("invalid period", cmd_name);
369 }
370
371 cmd->set_period(atoi(time.c_str()), unit);
372 args.erase(args.begin());
373 } else if (args[0] == "-auth") {
374 // set authInfo
375 AuthInfo auth;
376 if (SheppObjSet::authInfo(auth, args) != 0) {
377 return cmd_def_reg_help("invalid auth", cmd_name);
378 }
379 cmd->set_authInfo(auth);
380 } else {
381 return cmd_def_reg_help("invalid syntax near \"" + args[0] + "\"",
382 cmd_name);
383 }
384 }
385
386 if (cmd->get_authInfo().get_pw().empty()) {
387 return cmd_def_reg_help("no auth info specified", cmd_name);
388 }
389
390 if (_debug) {
391 DefRegName name = cmd->get_name();
392 printf("creating defensive registration: [%s:%s]\n",
393 name.get_name().c_str(),
394 DefRegLevel::toStr(name.get_level()).c_str());
395 printf(" registrant: %s\n", cmd->get_registrant().c_str());
396 printf(" admin contact: %s\n", cmd->get_admin_contact().c_str());
397
398 if (!cmd->get_trademark_id().empty()) {
399 printf(" trademark id: %s\n", cmd->get_trademark_id().c_str());
400 }
401
402 if (!cmd->get_trademark_country().empty()) {
403 printf(" trademark country: %s\n", cmd->get_trademark_country().c_str());
404 }
405
406 if (!cmd->get_trademark_date().empty()) {
407 printf(" trademark date: %s\n", cmd->get_trademark_date().c_str());
408 }
409
410 if (cmd->get_period().time != 0) {
411 printf(" period: %d %s\n", cmd->get_period().time,
412 cmd->get_period().unit.c_str());
413 }
414
415 SheppPrint::authInfo(cmd->get_authInfo());
416 } // _debug
417
418 if (process_action(act) != 0) {
419 return -1;
420 }
421
422 return 0;
423 }
424
425 /// defensive registration delete command function
426 /**
427 @param args vector with command-line arguments
428 @return 0 if ok, -1 otherwise
429 */
cmd_def_reg_delete(vector<string> & args)430 int cmd_def_reg_delete(vector<string> &args)
431 {
432 DefRegDelete act;
433 DefRegDeleteCmd *cmd = act.get_command();
434 string cmd_name = "delete";
435
436 if (args.empty()) {
437 return cmd_def_reg_help("no roid specified", cmd_name);
438 }
439
440 cmd->set_roid(args[0]);
441 args.erase(args.begin());
442
443 if (!args.empty()) {
444 return cmd_def_reg_help("invalid syntax near \"" + args[0] + "\"", cmd_name);
445 }
446
447 if (_debug) {
448 printf("defensive registration to delete: [%s]\n", cmd->get_roid().c_str());
449 } // _debug
450
451 if (process_action(act) != 0) {
452 return -1;
453 }
454
455 return 0;
456 }
457
458 /// defensive registration renew command function
459 /**
460 @param args vector with command-line arguments
461 @return 0 if ok, -1 otherwise
462 */
cmd_def_reg_renew(vector<string> & args)463 int cmd_def_reg_renew(vector<string> &args)
464 {
465 DefRegRenew act;
466 DefRegRenewCmd *cmd = act.get_command();
467 string cmd_name = "renew";
468
469 if (args.empty()) {
470 return cmd_def_reg_help("no roid specified", cmd_name);
471 }
472
473 cmd->set_roid(args[0]);
474 args.erase(args.begin());
475
476 while (!args.empty()) {
477 if (args[0] == "-expdate") {
478 //-expdate
479 args.erase(args.begin());
480 if (args.empty()) {
481 return cmd_domain_help("curExpDate missing", cmd_name);
482 }
483 cmd->set_cur_exp_date(args[0]);
484 args.erase(args.begin());
485 } else if (args[0] == "-period") {
486 args.erase(args.begin());
487 if (args.empty()) {
488 return cmd_domain_help("period missing", cmd_name);
489 }
490 string str_time;
491 string unit;
492 if (SheppStrUtil::split(args[0], str_time, unit, ":", false) != 0) {
493 return cmd_domain_help("error setting period", cmd_name);
494 }
495 cmd->set_period(atoi(str_time.c_str()), unit);
496 args.erase(args.begin());
497 } else {
498 return cmd_domain_help("invalid syntax near \"" + args[0] + "\"",
499 cmd_name);
500 }
501 }
502
503 if (_debug) {
504 printf("defensive registration to renew: [%s]\n", cmd->get_roid().c_str());
505 printf(" curExpDate: [%s]\n", cmd->get_cur_exp_date().c_str());
506 if (cmd->get_period().time != 0 || cmd->get_period().unit != "") {
507 printf(" period: [%d %s]\n",
508 cmd->get_period().time,
509 cmd->get_period().unit.c_str());
510 }
511 } // _debug
512
513 if (process_action(act) != 0) {
514 return -1;
515 }
516
517 return 0;
518 }
519
520 /// defensive registration update command function
521 /**
522 @param args vector with command-line arguments
523 @return 0 if ok, -1 otherwise
524 */
cmd_def_reg_update(vector<string> & args)525 int cmd_def_reg_update(vector<string> &args)
526 {
527 DefRegUpdate act;
528 DefRegUpdateCmd *cmd = act.get_command();
529 string cmd_name = "update";
530
531 if (args.empty()) {
532 return cmd_def_reg_help("no roid specified", cmd_name);
533 }
534
535 cmd->set_roid(args[0]);
536 args.erase(args.begin());
537
538 while (!args.empty()) {
539 if (args[0] == "-add-status") {
540 //status to add
541 args.erase(args.begin());
542 if (args.empty()) {
543 return cmd_domain_help("add-status parameter missing", cmd_name);
544 }
545
546 DefRegUpdateCmd::Status st;
547 if (SheppObjSet::status(st, args) != 0) {
548 return cmd_domain_help("invalid status to add", cmd_name);
549 }
550 cmd->insert_status_add(st);
551
552 } else if (args[0] == "-rem-status") {
553 //status to remove
554 args.erase(args.begin());
555 if (args.empty()) {
556 return cmd_domain_help("rem-status parameter missing", cmd_name);
557 }
558
559 DefRegUpdateCmd::Status st(args[0]);
560 args.erase(args.begin());
561
562 cmd->insert_status_rem(st);
563
564 } else if (args[0] == "-r") {
565 // registrant
566 args.erase(args.begin());
567 if (args.empty()) {
568 return cmd_domain_help("registrant parameter missing", cmd_name);
569 }
570
571 cmd->set_registrant(args[0]);
572 args.erase(args.begin());
573
574 } else if (args[0] == "-a") {
575 // admin contact
576 args.erase(args.begin());
577 if (args.empty()) {
578 return cmd_domain_help("admin contact parameter missing", cmd_name);
579 }
580
581 cmd->set_admin_contact(args[0]);
582 args.erase(args.begin());
583
584 } else if (args[0] == "-tm") {
585 //trademark
586 args.erase(args.begin());
587 if (args.empty()) {
588 return cmd_domain_help("trademark parameter missing", cmd_name);
589 }
590
591 cmd->set_trademark_id(args[0]);
592 args.erase(args.begin());
593
594 } else if (args[0] == "-tmc") {
595 //trademark country
596 args.erase(args.begin());
597 if (args.empty()) {
598 return cmd_domain_help("trademark country parameter missing", cmd_name);
599 }
600
601 cmd->set_trademark_country(args[0]);
602 args.erase(args.begin());
603
604 } else if (args[0] == "-tmd") {
605 //trademark date
606 args.erase(args.begin());
607 if (args.empty()) {
608 return cmd_domain_help("trademark date parameter missing", cmd_name);
609 }
610
611 cmd->set_trademark_date(args[0]);
612 args.erase(args.begin());
613
614 } else if (args[0] == "-auth") {
615 // set authInfo
616 AuthInfo auth;
617 if (SheppObjSet::authInfo(auth, args) != 0) {
618 return cmd_def_reg_help("invalid auth", cmd_name);
619 }
620 cmd->set_authInfo(auth);
621 } else {
622 return cmd_def_reg_help("invalid syntax near \"" + args[0] + "\"",
623 cmd_name);
624 }
625 }
626
627 if (_debug) {
628 printf("updating defensive registration: [%s]\n", cmd->get_roid().c_str());
629
630 set<DefRegUpdateCmd::Status> statuses = cmd->get_status_add();
631 set<DefRegUpdateCmd::Status>::const_iterator stit;
632 if (!statuses.empty()) {
633 printf(" status to add:\n");
634 }
635 for (stit = statuses.begin(); stit != statuses.end(); stit++) {
636 printf(" s : [%s]\n", (*stit).get_status().c_str());
637 printf(" lang: [%s]\n", (*stit).get_lang().c_str());
638 printf(" msg : [%s]\n", (*stit).get_msg().c_str());
639 }
640 statuses = cmd->get_status_rem();
641 if (!statuses.empty()) {
642 printf(" status to remove:\n");
643 }
644 for (stit = statuses.begin(); stit != statuses.end(); stit++) {
645 printf(" s : [%s]\n", (*stit).get_status().c_str());
646 printf(" lang: [%s]\n", (*stit).get_lang().c_str());
647 printf(" msg : [%s]\n", (*stit).get_msg().c_str());
648 }
649
650 printf(" registrant: %s\n", cmd->get_registrant().c_str());
651 printf(" admin contact: %s\n", cmd->get_admin_contact().c_str());
652
653 if (!cmd->get_trademark_id().empty()) {
654 printf(" trademark id: %s\n", cmd->get_trademark_id().c_str());
655 }
656
657 if (!cmd->get_trademark_country().empty()) {
658 printf(" trademark country: %s\n", cmd->get_trademark_country().c_str());
659 }
660
661 if (!cmd->get_trademark_date().empty()) {
662 printf(" trademark date: %s\n", cmd->get_trademark_date().c_str());
663 }
664
665 SheppPrint::authInfo(cmd->get_authInfo());
666 } // _debug
667
668 if (process_action(act) != 0) {
669 return -1;
670 }
671
672 return 0;
673 }
674
675 /// main defensive registration command
676 /**
677 @param arg command-line input arguments
678 @return 0 if ok, -1 otherwise
679 */
cmd_def_reg(vector<string> & args)680 int cmd_def_reg(vector<string> &args)
681 {
682 // defensive registration command processing
683 if (!args.empty() && !(args[0] == "help")) {
684 if (args[0] == "check") {
685 args.erase(args.begin());
686 return cmd_def_reg_check(args);
687 } else if (args[0] == "info") {
688 args.erase(args.begin());
689 return cmd_def_reg_info(args);
690 } else if (args[0] == "transfer") {
691 args.erase(args.begin());
692 return cmd_def_reg_transfer(args);
693 } else if (args[0] == "create") {
694 args.erase(args.begin());
695 return cmd_def_reg_create(args);
696 } else if (args[0] == "delete") {
697 args.erase(args.begin());
698 return cmd_def_reg_delete(args);
699 } else if (args[0] == "renew") {
700 args.erase(args.begin());
701 return cmd_def_reg_renew(args);
702 } else if (args[0] == "update") {
703 args.erase(args.begin());
704 return cmd_def_reg_update(args);
705 } else {
706 return cmd_def_reg_help("invalid command: defreg " + args[0]);
707 }
708 }
709
710 return cmd_def_reg_help("");
711 }
712
713 #endif // __DEF_REG_FUNCTIONS_H__
714