src/shepp/IpNetworkFunctions.H

Go to the documentation of this file.
00001 /* ${copyright}$ */
00002 /* $Id: IpNetworkFunctions.H 1010 2009-03-12 17:50:50Z eduardo $ */
00006 #ifndef __IPNETWORK_FUNCTIONS_H__
00007 #define __IPNETWORK_FUNCTIONS_H__
00008 #include "SheppCommandFunctions.H"
00009 
00010 #include "IpNetworkCheck.H"
00011 #include "IpNetworkCreate.H"
00012 #include "IpNetworkDelete.H"
00013 #include "IpNetworkInfo.H"
00014 #include "IpNetworkRenew.H"
00015 #include "IpNetworkTransfer.H"
00016 #include "IpNetworkUpdate.H"
00017 
00019 
00024 int cmd_ipnetwork_help(string error_msg, string specific = "")
00025 {
00026   if (error_msg != "") {
00027     printf("error: %s\n", error_msg.c_str());
00028   }
00029 
00030   printf("ipnetwork command syntax help:\n");
00031   printf("\n");
00032 
00033   if (specific == "" || specific == "check") {
00034     printf("  check <<v4|v6>=<startAddr>-<endAddr>> "
00035            "[<v4|v6>=<startAddr>-<endAddr> ...]\n");
00036     printf("\n");
00037   }
00038   if (specific == "" || specific == "create") {
00039     printf("  create <v4|v6>=<startAddr>-<endAddr> <-o organization> "
00040            "[-t allocType]\n"
00041            "    [-a asn] [-contact type=value ...] \n"
00042            "    [-rev-ns "
00043            "<v4|v6>=<startAddr>-<endAddr>,hostname[,hostname ...] ...]\n");
00044     printf("\n");
00045   }
00046   if (specific == "" || specific == "delete") {
00047     printf("  delete <-roid repository-id>\n");
00048     printf("\n");
00049   }
00050   if (specific == "" || specific == "info") {
00051     printf("  info <<v4|v6>=<startAddr>-<endAddr>> [-roid repository-id]\n");
00052     printf("\n");
00053   }
00054   if (specific == "" || specific == "renew") {
00055     printf("  renew <-roid repository-id> <-expdate expDate> "
00056            "[-period time:unit]\n");
00057     printf("\n");
00058   }
00059   if (specific == "" || specific == "transfer") {
00060     printf("  transfer <-op [query|request]> <-roid repository-id>\n");
00061     printf("\n");
00062   }
00063   if (specific == "" || specific == "update") {
00064     printf("  update <roid> [-add-contact type=value ...]\n"
00065            "    [-rem-contact type=value ...] [-o organization] "
00066            "[-t allocationType]\n"
00067            "    [-add-rev-ns "
00068            "<v4|v6>=<startAddr>-<endAddr>,hostname[,hostname ...] ...]\n"
00069            "    [-rem-rev-ns "
00070            "<v4|v6>=<startAddr>-<endAddr>,hostname[,hostname ...] ...]\n");
00071     printf("\n");
00072   }
00073 
00074   if (error_msg != "") {
00075     return -1;
00076   }
00077 
00078   return 0;
00079 }
00080 
00082 
00087 int parse_iprange(const string &input, IpRange &ipRange) {
00088   string error_msg("");
00089 
00090   string version;
00091   string range;
00092   string ipBegin;
00093   string ipEnd;
00094 
00095   if (SheppStrUtil::split(input, version, range, "=", false) != 0 ||
00096       SheppStrUtil::split(range, ipBegin, ipEnd, "-", false) != 0) {
00097     return -1;
00098   }
00099 
00100   ipRange.set_version(version);
00101   ipRange.set_ipBegin(ipBegin);
00102   ipRange.set_ipEnd(ipEnd);
00103 
00104   return 0;
00105 }
00106 
00108 
00112 int cmd_ipnetwork_check(vector<string> &args)
00113 {
00114   string cmd_name = "check";
00115 
00116   IpNetworkCheck act;
00117   IpNetworkCheckCmd *cmd = act.get_command();
00118 
00119   while (!args.empty()) {
00120     if (args[0].substr(0,1) == "v") {
00121       //IP range
00122       IpRange ipRange;
00123       if (parse_iprange(args[0], ipRange) != 0) {
00124         return cmd_ipnetwork_help("invalid IP range", cmd_name);
00125       }
00126       args.erase(args.begin());
00127       cmd->insert_ipRange(ipRange);
00128     } else {
00129       return cmd_ipnetwork_help("invalid syntax near \"" + args[0] + "\"",
00130                                 cmd_name);
00131     }
00132   }
00133 
00134   // check mandatory fields
00135   if (cmd->get_ipRanges().empty()) {
00136     return cmd_ipnetwork_help("no IP ranges specified", cmd_name);
00137   }
00138 
00139   if (_debug) {
00140     vector<IpRange> ipRanges = cmd->get_ipRanges();
00141     printf("ranges to be checked:\n");
00142     for (unsigned int i = 0; i < ipRanges.size(); i++) {
00143       printf("  (%s) from [%s] to [%s]\n",
00144              ipRanges[i].get_version().c_str(),
00145              ipRanges[i].get_ipBegin().c_str(),
00146              ipRanges[i].get_ipEnd().c_str());
00147     }
00148   } // _debug
00149 
00150   if (process_action(act) != 0) {
00151     return -1;
00152   }
00153 
00154   return 0;
00155 }
00156 
00158 
00162 int cmd_ipnetwork_create(vector<string> &args)
00163 {
00164   string cmd_name = "create";
00165 
00166   IpNetworkCreate act;
00167   IpNetworkCreateCmd *cmd = act.get_command();
00168 
00169   // mandatory fields
00170   bool hasIpRange = false;
00171   bool hasOrganization = false;
00172 
00173   while (!args.empty()) {
00174     if (args[0].substr(0,1) == "v") {
00175       //IP range
00176       if (hasIpRange) {
00177         return cmd_ipnetwork_help("only one IP range allowed per command",
00178                                   cmd_name);
00179       } else {
00180         hasIpRange = true;
00181       }
00182       IpRange ipRange;
00183       if (parse_iprange(args[0], ipRange) != 0) {
00184         return cmd_ipnetwork_help("invalid IP range", cmd_name);
00185       }
00186       args.erase(args.begin());
00187       cmd->set_ipRange(ipRange);
00188     } else if (args[0] == "-o") {
00189       //set organization
00190       if (hasOrganization) {
00191         return cmd_ipnetwork_help("only one organization allowed per command",
00192                                   cmd_name);
00193       } else {
00194         hasOrganization = true;
00195       }
00196       args.erase(args.begin());
00197       if (args.empty()) {
00198         return cmd_ipnetwork_help("organization parameter missing", cmd_name);
00199       }
00200       cmd->set_organization(args[0]);
00201       args.erase(args.begin());
00202     } else if (args[0] == "-t") {
00203       //set allocType
00204       args.erase(args.begin());
00205       if (args.empty()) {
00206         return cmd_ipnetwork_help("allocType parameter missing", cmd_name);
00207       }
00208       cmd->set_allocType(args[0]);
00209       args.erase(args.begin());
00210     } else if (args[0] == "-a") {
00211       //set asn
00212       args.erase(args.begin());
00213       if (args.empty()) {
00214         return cmd_ipnetwork_help("asn parameter missing", cmd_name);
00215       }
00216 
00217       if (atoi(args[0].c_str()) <= 0) {
00218         return cmd_ipnetwork_help("asn parameter must be a positive integer",
00219                                cmd_name);
00220       }
00221 
00222       cmd->set_asn(atoi(args[0].c_str()));
00223       args.erase(args.begin());
00224     } else if (args[0] == "-contact") {
00225       //contact
00226       args.erase(args.begin());
00227       if (args.empty()) {
00228         return cmd_ipnetwork_help("contact parameter missing", cmd_name);
00229       }
00230 
00231       string type;
00232       string value;
00233       if (SheppStrUtil::split(args[0], type, value, "=", false) != 0) {
00234         return cmd_ipnetwork_help("invalid contact", cmd_name);
00235       }
00236 
00237       cmd->insert_contact(type, value);
00238       args.erase(args.begin());      
00239     } else if (args[0] == "-rev-ns") {
00240       //reverse ns
00241       args.erase(args.begin());
00242       if (args.empty()) {
00243         return cmd_ipnetwork_help("reverse DNS parameter missing", cmd_name);
00244       }
00245 
00246       ReverseDns revDns;
00247       string range;
00248       string nameservers;
00249       if (SheppStrUtil::split(args[0], range, nameservers, ",", false) != 0 ||
00250           parse_iprange(range, revDns.ipRange) != 0) {
00251         return cmd_ipnetwork_help("invalid reverse DNS", cmd_name);
00252       }
00253 
00254       string tmp1 = nameservers;
00255       string tmp2;
00256       while (SheppStrUtil::split(tmp1, tmp1, tmp2, ",", true) == 0) {
00257         revDns.nameservers.push_back(tmp1);
00258         if (tmp2 == "") {
00259           break;
00260         }
00261         tmp1 = tmp2;
00262       }
00263 
00264       cmd->insert_reverseDns(revDns);
00265       args.erase(args.begin());
00266     } else {
00267       return cmd_ipnetwork_help("invalid syntax near \"" + args[0] + "\"",
00268                                 cmd_name);
00269     }
00270   }
00271 
00272   // check mandatory fields
00273   if (!hasIpRange) {
00274     return cmd_ipnetwork_help("no IP range specified", cmd_name);
00275   }
00276 
00277   if (!hasOrganization) {
00278     return cmd_ipnetwork_help("no organization specified", cmd_name);
00279   }
00280 
00281   if (_debug) {
00282     IpRange ipRange = cmd->get_ipRange();
00283     printf("range to be created:\n");
00284     printf("  (%s) from [%s] to [%s]\n",
00285            ipRange.get_version().c_str(),
00286            ipRange.get_ipBegin().c_str(),
00287            ipRange.get_ipEnd().c_str());
00288     printf("organization: [%s]\n", cmd->get_organization().c_str());
00289     printf("allocType: [%s]\n", cmd->get_allocType().c_str());
00290     if (cmd->get_asn() > 0) {
00291       printf("asn: [%d]\n", cmd->get_asn());
00292     }
00293     map< string, string, less<string> > contacts = cmd->get_contacts();
00294     map< string, string, less<string> >::const_iterator cit;
00295     for (cit = contacts.begin(); cit != contacts.end(); cit++) {
00296       printf("contact %s: %s\n", (*cit).first.c_str(), (*cit).second.c_str());
00297     }
00298 
00299     printf("reverse nameservers:\n");
00300     vector<ReverseDns> revNs = cmd->get_reversesDns();
00301     for (unsigned int i = 0; i < revNs.size(); i++) {
00302       printf("  range (%s) from [%s] to [%s]:\n",
00303              revNs[i].ipRange.get_version().c_str(),
00304              revNs[i].ipRange.get_ipBegin().c_str(),
00305              revNs[i].ipRange.get_ipEnd().c_str());
00306       for (unsigned int j = 0; j < revNs[i].nameservers.size(); j++) {
00307         printf("    nameserver: [%s]\n", revNs[i].nameservers[j].c_str());
00308       }
00309     }
00310   } // _debug
00311 
00312   if (process_action(act) != 0) {
00313     return -1;
00314   }
00315 
00316   return 0;
00317 }
00318 
00320 
00324 int cmd_ipnetwork_delete(vector<string> &args)
00325 {
00326   string cmd_name = "delete";
00327 
00328   IpNetworkDelete act;
00329   IpNetworkDeleteCmd *cmd = act.get_command();
00330 
00331   // mandatory field
00332   bool hasRoid = false;
00333 
00334   while (!args.empty()) {
00335     if (args[0] == "-roid") {
00336       //roid
00337       if (hasRoid) {
00338         return cmd_ipnetwork_help("only one repository ID allowed per command",
00339                                   cmd_name);
00340       } else {
00341         hasRoid = true;
00342       }
00343       args.erase(args.begin());
00344       if (args.empty()) {
00345         return cmd_ipnetwork_help("repository ID parameter missing", cmd_name);
00346       }
00347 
00348       cmd->set_roid(args[0]);
00349       args.erase(args.begin());
00350     } else {
00351       return cmd_ipnetwork_help("invalid syntax near \"" + args[0] + "\"",
00352                                 cmd_name);
00353     }
00354   }
00355 
00356   if (!hasRoid) {
00357     return cmd_ipnetwork_help("no repository ID specified", cmd_name);
00358   }
00359 
00360   if (_debug) {
00361     printf("roid: [%s]\n", cmd->get_roid().c_str());
00362   } // _debug
00363 
00364   if (process_action(act) != 0) {
00365     return -1;
00366   }
00367 
00368   return 0;
00369 }
00370 
00372 
00376 int cmd_ipnetwork_info(vector<string> &args)
00377 {
00378   string cmd_name = "info";
00379 
00380   IpNetworkInfo act;
00381   IpNetworkInfoCmd *cmd = act.get_command();
00382 
00383   // mandatory field
00384   bool hasIpRange = false;
00385 
00386   while (!args.empty()) {
00387     if (args[0].substr(0,1) == "v") {
00388       //IP range
00389       if (hasIpRange) {
00390         return cmd_ipnetwork_help("only one IP range allowed per command",
00391                                   cmd_name);
00392       } else {
00393         hasIpRange = true;
00394       }
00395       IpRange ipRange;
00396       if (parse_iprange(args[0], ipRange) != 0) {
00397         return cmd_ipnetwork_help("invalid IP range", cmd_name);
00398       }
00399       args.erase(args.begin());
00400       cmd->set_ipRange(ipRange);
00401     } else if (args[0] == "-roid") {
00402       //roid
00403       args.erase(args.begin());
00404       if (args.empty()) {
00405         return cmd_ipnetwork_help("repository ID parameter missing", cmd_name);
00406       }
00407 
00408       cmd->set_roid(args[0]);
00409       args.erase(args.begin());
00410     } else {
00411       return cmd_ipnetwork_help("invalid syntax near \"" + args[0] + "\"",
00412                                 cmd_name);
00413     }
00414   }
00415 
00416   // check mandatory field
00417   if (!hasIpRange) {
00418     return cmd_ipnetwork_help("no IP range specified", cmd_name);
00419   }
00420 
00421   if (_debug) {
00422     IpRange ipRange = cmd->get_ipRange();
00423     printf("range to get info:\n");
00424     printf("  (%s) from [%s] to [%s]\n",
00425            ipRange.get_version().c_str(),
00426            ipRange.get_ipBegin().c_str(),
00427            ipRange.get_ipEnd().c_str());
00428 
00429     if (cmd->get_roid() != "") {
00430       printf("roid: [%s]\n", cmd->get_roid().c_str());
00431     }
00432   } // _debug
00433 
00434   if (process_action(act) != 0) {
00435     return -1;
00436   }
00437 
00438   return 0;
00439 }
00440 
00442 
00446 int cmd_ipnetwork_renew(vector<string> &args)
00447 {
00448   string cmd_name = "renew";
00449 
00450   IpNetworkRenew act;
00451   IpNetworkRenewCmd *cmd = act.get_command();
00452 
00453   // mandatory fields
00454   bool hasRoid = false;
00455   bool hasExpDate = false;
00456 
00457   while (!args.empty()) {
00458     if (args[0] == "-roid") {
00459       //roid
00460       if (hasRoid) {
00461         return cmd_ipnetwork_help("only one repository ID allowed per command",
00462                                   cmd_name);
00463       } else {
00464         hasRoid = true;
00465       }
00466       args.erase(args.begin());
00467       if (args.empty()) {
00468         return cmd_ipnetwork_help("repository ID parameter missing", cmd_name);
00469       }
00470 
00471       cmd->set_roid(args[0]);
00472       args.erase(args.begin());
00473     } else if (args[0] == "-expdate") {
00474       //expdate
00475       if (hasExpDate) {
00476         return cmd_ipnetwork_help("only one expDate allowed per command",
00477                                   cmd_name);
00478       } else {
00479         hasExpDate = true;
00480       }
00481       args.erase(args.begin());
00482       if (args.empty()) {
00483         return cmd_ipnetwork_help("expDate missing", cmd_name);
00484       }
00485       cmd->set_expDate(args[0]);
00486       args.erase(args.begin());      
00487     } else if (args[0] == "-period") {
00488       //period
00489       args.erase(args.begin());
00490       if (args.empty()) {
00491         return cmd_ipnetwork_help("period parameter missing", cmd_name);
00492       }
00493 
00494       string time;
00495       string unit;
00496       if (SheppStrUtil::split(args[0], time, unit, ":", false) != 0) {
00497         return cmd_ipnetwork_help("invalid period", cmd_name);
00498       }
00499 
00500       cmd->set_period(atoi(time.c_str()), unit);
00501       args.erase(args.begin());
00502     } else {
00503       return cmd_ipnetwork_help("invalid syntax near \"" + args[0] + "\"",
00504                                 cmd_name);
00505     }
00506   }
00507 
00508   // check mandatory fields
00509   if (!hasRoid) {
00510     return cmd_ipnetwork_help("no repository ID specified", cmd_name);
00511   }
00512 
00513   if (!hasExpDate) {
00514     return cmd_ipnetwork_help("no expDate specified", cmd_name);
00515   }
00516 
00517   if (_debug) {
00518     printf("roid   : [%s]\n", cmd->get_roid().c_str());
00519     printf("expDate: [%s]\n", cmd->get_expDate().c_str());
00520     if (cmd->get_period().time != 0 || cmd->get_period().unit != "") {
00521       printf("period : [%d %s]\n", cmd->get_period().time,
00522              cmd->get_period().unit.c_str());
00523     }
00524   } // _debug
00525 
00526   if (process_action(act) != 0) {
00527     return -1;
00528   }
00529 
00530   return 0;
00531 }
00532 
00534 
00538 int cmd_ipnetwork_transfer(vector<string> &args)
00539 {
00540   string cmd_name = "transfer";
00541 
00542   IpNetworkTransfer act;
00543   IpNetworkTransferCmd *cmd = act.get_command();
00544 
00545   // mandatory fields
00546   bool hasRoid = false;
00547   bool hasOp = false;
00548 
00549   while (!args.empty()) {
00550     if (args[0] == "-roid") {
00551       //roid
00552       if (hasRoid) {
00553         return cmd_ipnetwork_help("only one repository ID allowed per command",
00554                                   cmd_name);
00555       } else {
00556         hasRoid = true;
00557       }
00558       args.erase(args.begin());
00559       if (args.empty()) {
00560         return cmd_ipnetwork_help("repository ID parameter missing", cmd_name);
00561       }
00562 
00563       cmd->set_roid(args[0]);
00564       args.erase(args.begin());
00565     } else if (args[0] == "-op") {
00566       //op
00567       if (hasOp) {
00568         return cmd_ipnetwork_help("only one operation allowed per command",
00569                                   cmd_name);
00570       } else {
00571         hasOp = true;
00572       }
00573       args.erase(args.begin());
00574       if (args.empty()) {
00575         return cmd_ipnetwork_help("operation parameter missing", cmd_name);
00576       }
00577 
00578       if (args[0] != "query" && args[0] != "request") {
00579         return cmd_ipnetwork_help("invalid operation '" + args[0] + "'",
00580                                   cmd_name);
00581       }
00582 
00583       cmd->set_operation(args[0]);
00584       args.erase(args.begin());
00585     } else {
00586       return cmd_ipnetwork_help("invalid syntax near \"" + args[0] + "\"",
00587                                 cmd_name);
00588     }
00589   }
00590 
00591   if (!hasRoid) {
00592     return cmd_ipnetwork_help("no repository ID specified", cmd_name);
00593   }
00594 
00595   if (!hasOp) {
00596     return cmd_ipnetwork_help("no operation specified", cmd_name);
00597   }
00598 
00599   if (_debug) {
00600     printf("roid: [%s]\n", cmd->get_roid().c_str());
00601     printf("op  : [%s]\n", cmd->get_operation().c_str());
00602   } // _debug
00603 
00604   if (process_action(act) != 0) {
00605     return -1;
00606   }
00607 
00608   return 0;
00609 }
00610 
00612 
00616 int cmd_ipnetwork_update(vector<string> &args)
00617 {
00618   string cmd_name = "update";
00619 
00620   IpNetworkUpdate act;
00621   IpNetworkUpdateCmd *cmd = act.get_command();
00622 
00623   if (args.empty()) {
00624     return cmd_ipnetwork_help("no ROID specified", cmd_name);
00625   }
00626 
00627   cmd->set_roid(args[0]);
00628   args.erase(args.begin());
00629   
00630   bool hasOrganization = false;
00631   bool hasAllocType = false;
00632   bool hasContactsAdd = false;
00633   bool hasContactsRem = false;
00634   bool hasReverseDnsAdd = false;
00635   bool hasReverseDnsRem = false;
00636 
00637   while (!args.empty()) {
00638     if (args[0] == "-add-contact") {
00639       //contact(s) to add
00640       hasContactsAdd = true;
00641       args.erase(args.begin());
00642       if (args.empty()) {
00643         return cmd_ipnetwork_help("add-contact parameter missing", cmd_name);
00644       }
00645 
00646       string type;
00647       string value;
00648       if (SheppStrUtil::split(args[0], type, value, "=", false) != 0) {
00649         return cmd_ipnetwork_help("invalid contact", cmd_name);
00650       }
00651 
00652       cmd->insert_contact_add(type, value);
00653       args.erase(args.begin());      
00654     } else if (args[0] == "-rem-contact") {
00655       //contact(s) to remove
00656       hasContactsRem = true;
00657       args.erase(args.begin());
00658       if (args.empty()) {
00659         return cmd_ipnetwork_help("rem-contact parameter missing", cmd_name);
00660       }
00661 
00662       string type;
00663       string value;
00664       if (SheppStrUtil::split(args[0], type, value, "=", false) != 0) {
00665         return cmd_ipnetwork_help("invalid contact", cmd_name);
00666       }
00667 
00668       cmd->insert_contact_rem(type, value);
00669       args.erase(args.begin());      
00670     } else if (args[0] == "-o") {
00671       //set organization
00672       if (hasOrganization) {
00673         return cmd_ipnetwork_help("only one organization allowed per command",
00674                                   cmd_name);
00675       } else {
00676         hasOrganization = true;
00677       }
00678       args.erase(args.begin());
00679       if (args.empty()) {
00680         return cmd_ipnetwork_help("organization parameter missing", cmd_name);
00681       }
00682       cmd->set_organization(args[0]);
00683       args.erase(args.begin());
00684     } else if (args[0] == "-t") {
00685       //set allocType
00686       if (hasAllocType) {
00687         return cmd_ipnetwork_help("only one allocation allowed per command",
00688                             cmd_name);
00689       } else {
00690         hasAllocType = true;
00691       }
00692       args.erase(args.begin());
00693       if (args.empty()) {
00694         return cmd_ipnetwork_help("allocType parameter missing", cmd_name);
00695       }
00696       cmd->set_allocType(args[0]);
00697       args.erase(args.begin());
00698     } else if (args[0] == "-add-rev-ns") {
00699       //reverse ns
00700       hasReverseDnsAdd = true;
00701       args.erase(args.begin());
00702       if (args.empty()) {
00703         return cmd_ipnetwork_help("reverse DNS parameter missing", cmd_name);
00704       }
00705       
00706       ReverseDns revDns;
00707       string range;
00708       string nameservers;
00709       if (SheppStrUtil::split(args[0], range, nameservers, ",", false) != 0 ||
00710           parse_iprange(range, revDns.ipRange) != 0) {
00711         return cmd_ipnetwork_help("invalid reverse DNS", cmd_name);
00712       }
00713       
00714       string tmp1 = nameservers;
00715       string tmp2;
00716       while (SheppStrUtil::split(tmp1, tmp1, tmp2, ",", true) == 0) {
00717         revDns.nameservers.push_back(tmp1);
00718         if (tmp2 == "") {
00719           break;
00720         }
00721         tmp1 = tmp2;
00722       }
00723       
00724       cmd->insert_reverseDNS_add(revDns);
00725       args.erase(args.begin());
00726     } else if (args[0] == "-rem-rev-ns") {
00727       hasReverseDnsRem = true;
00728       //reverse ns
00729       args.erase(args.begin());
00730       if (args.empty()) {
00731         return cmd_ipnetwork_help("reverse DNS parameter missing", cmd_name);
00732       }
00733       
00734       ReverseDns revDns;
00735       string range;
00736       string nameservers;
00737       if (SheppStrUtil::split(args[0], range, nameservers, ",", false) != 0 ||
00738           parse_iprange(range, revDns.ipRange) != 0) {
00739         return cmd_ipnetwork_help("invalid reverse DNS", cmd_name);
00740       }
00741       
00742       string tmp1 = nameservers;
00743       string tmp2;
00744       while (SheppStrUtil::split(tmp1, tmp1, tmp2, ",", true) == 0) {
00745         revDns.nameservers.push_back(tmp1);
00746         if (tmp2 == "") {
00747           break;
00748         }
00749         tmp1 = tmp2;
00750       }
00751       
00752       cmd->insert_reverseDNS_rem(revDns);
00753       args.erase(args.begin());
00754     } else {
00755       return cmd_ipnetwork_help("invalid syntax near \"" + args[0] + "\"",
00756                                 cmd_name);
00757     }
00758   }
00759 
00760   if (!hasOrganization && !hasContactsAdd && !hasContactsRem && 
00761       !hasAllocType && !hasReverseDnsAdd && !hasReverseDnsRem) {
00762     return cmd_ipnetwork_help("nothing to update", cmd_name);
00763   }
00764 
00765   if (_debug) {
00766     printf("IP Network to be updated: [%s]\n", cmd->get_roid().c_str());
00767     printf("organization: [%s]\n", cmd->get_organization().c_str());
00768     printf("allocation type: [%s]\n", cmd->get_allocType().c_str());
00769 
00770     map< string, string, less<string> >::const_iterator cit;
00771     map< string, string, less<string> > contacts;
00772 
00773     contacts = cmd->get_contacts_add();
00774     for (cit = contacts.begin(); cit != contacts.end(); cit++) {
00775       printf("contact to add %s: %s\n",
00776              (*cit).first.c_str(), (*cit).second.c_str());
00777     }
00778 
00779     contacts = cmd->get_contacts_rem();
00780     for (cit = contacts.begin(); cit != contacts.end(); cit++) {
00781       printf("contact to remove %s: %s\n",
00782              (*cit).first.c_str(), (*cit).second.c_str());
00783     }
00784 
00785     vector<ReverseDns> reverseDns;
00786 
00787     reverseDns = cmd->get_reverseDns_add();
00788     for (unsigned int i = 0; i < reverseDns.size(); i++) {
00789       IpRange ipRange = reverseDns[i].ipRange;
00790       printf("reverse DNS to add: [%s] from [%s] to [%s]\n", 
00791              ipRange.get_version().c_str(), 
00792              ipRange.get_ipBegin().c_str(), 
00793              ipRange.get_ipEnd().c_str());
00794       vector<string> nameservers = reverseDns[i].nameservers;
00795       for (unsigned int j = 0; j < nameservers.size(); j++) {
00796         printf("  nameserver [%s]\n", nameservers[j].c_str());
00797       }
00798     }
00799 
00800     reverseDns = cmd->get_reverseDns_rem();
00801     for (unsigned int i = 0; i < reverseDns.size(); i++) {
00802       IpRange ipRange = reverseDns[i].ipRange;
00803       printf("reverse DNS to remove: [%s] from [%s] to [%s]\n", 
00804              ipRange.get_version().c_str(), 
00805              ipRange.get_ipBegin().c_str(), 
00806              ipRange.get_ipEnd().c_str());
00807       vector<string> nameservers = reverseDns[i].nameservers;
00808       for (unsigned int j = 0; j < nameservers.size(); j++) {
00809         printf("  nameserver [%s]\n", nameservers[j].c_str());
00810       }
00811     }
00812   } // _debug
00813 
00814   if (process_action(act) != 0) {
00815     return -1;
00816   }
00817 
00818   return 0;
00819 }
00820 
00822 
00826 int cmd_ipnetwork(vector<string> &args)
00827 {
00828   // ipnetwork command processing
00829   if (!args.empty() && !(args[0] == "help")) {
00830     if (args[0] == "check") {
00831       args.erase(args.begin());
00832       return cmd_ipnetwork_check(args);
00833     } else if (args[0] == "create") {
00834       args.erase(args.begin());
00835       return cmd_ipnetwork_create(args);
00836     } else if (args[0] == "delete") {
00837       args.erase(args.begin());
00838       return cmd_ipnetwork_delete(args);
00839     } else if (args[0] == "info") {
00840       args.erase(args.begin());
00841       return cmd_ipnetwork_info(args);
00842     } else if (args[0] == "renew") {
00843       args.erase(args.begin());
00844       return cmd_ipnetwork_renew(args);
00845     } else if (args[0] == "transfer") {
00846       args.erase(args.begin());
00847       return cmd_ipnetwork_transfer(args);
00848     } else if (args[0] == "update") {
00849       args.erase(args.begin());
00850       return cmd_ipnetwork_update(args);
00851     } else {
00852       return cmd_ipnetwork_help("invalid command: ipnetwork " + args[0]);
00853     }
00854   }
00855   
00856   return cmd_ipnetwork_help("");
00857 }
00858 
00859 #endif //__IPNETWORK_FUNCTIONS_H__

Generated on Tue Mar 17 16:03:07 2009 for libepp_nicbr by  doxygen 1.4.7