0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034 #include <string.h>
0035 #include <stdio.h>
0036 #include <stdlib.h>
0037 #include <memory.h>
0038 #include <sys/param.h>
0039 #include <unistd.h>
0040
0041 #include <ndrstandard.h>
0042 #include <ndebug.h>
0043
0044 #include <ndrx.h>
0045 #include <ndrxdcmn.h>
0046 #include <atmi_int.h>
0047 #include <gencall.h>
0048 #include <nclopt.h>
0049 #include <lcfint.h>
0050 #include <singlegrp.h>
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066 exprivate char *proc_state_to_str(long state, short msg_type)
0067 {
0068 static char *started = "Started";
0069 static char *not_started = "Not started";
0070 static char *died = "Died";
0071 static char *shutdown = "Shutdown succeeded";
0072 static char *stopping = "Shutdown in progress";
0073 static char *nosuchfile = "No such file or directory";
0074 static char *eaccess = "Access denied";
0075 static char *ebadfile = "Bad executable";
0076 static char *elimits = "Limits exceeded";
0077 static char *stillstarting = "Still starting";
0078 static char *eargslim = "Cli args on env params too long";
0079 static char *eenv= "Environment setup failure";
0080 static char *esys= "System failure";
0081 static char *restart= "Restarting";
0082 static char *ewait= "Waiting on group lock";
0083 static char unknown[256];
0084 char *ret;
0085
0086 switch (state)
0087 {
0088 case NDRXD_PM_NOT_STARTED:
0089 ret = not_started;
0090 break;
0091 case NDRXD_PM_RUNNING_OK:
0092 ret = started;
0093 break;
0094 case NDRXD_PM_DIED:
0095 ret = died;
0096 break;
0097 case NDRXD_PM_STARTING:
0098 ret = stillstarting;
0099 break;
0100 case NDRXD_PM_EXIT:
0101
0102 if (NDRXD_CALL_TYPE_PM_STOPPED==msg_type)
0103 {
0104 ret = shutdown;
0105 }
0106 else
0107 {
0108 ret = died;
0109 }
0110 break;
0111 case NDRXD_PM_ENOENT:
0112 ret = nosuchfile;
0113 break;
0114 case NDRXD_PM_EACCESS:
0115 ret = eaccess;
0116 break;
0117 case NDRXD_PM_EBADFILE:
0118 ret = ebadfile;
0119 break;
0120 case NDRXD_PM_ELIMIT:
0121 ret = elimits;
0122 break;
0123 case NDRXD_PM_STOPPING:
0124 ret = stopping;
0125 break;
0126 case NDRXD_PM_EARGSLIM:
0127 ret = eargslim;
0128 break;
0129 case NDRXD_PM_EENV:
0130 ret = eenv;
0131 break;
0132 case NDRXD_PM_ESYSTEM:
0133 ret = esys;
0134 break;
0135 case NDRXD_PM_RESTART:
0136 ret = restart;
0137 break;
0138 case NDRXD_PM_WAIT:
0139 ret = ewait;
0140 break;
0141 default:
0142 snprintf(unknown, sizeof(unknown), "Unknown state (%ld)", state);
0143 ret = unknown;
0144 break;
0145 }
0146
0147 return ret;
0148 }
0149
0150
0151
0152
0153
0154
0155 expublic int ss_rsp_process(command_reply_t *reply, size_t reply_len)
0156 {
0157 command_reply_pm_t * pm_info = (command_reply_pm_t*)reply;
0158
0159 switch (reply->msg_type)
0160 {
0161 case NDRXD_CALL_TYPE_PM_STARTING:
0162 fprintf(stderr, "exec %s %s :\n\t",
0163 pm_info->binary_name, pm_info->clopt);
0164 break;
0165 case NDRXD_CALL_TYPE_PM_STARTED:
0166 fprintf(stderr, "process id=%d ... %s.\n",pm_info->pid,
0167 proc_state_to_str(pm_info->state, reply->msg_type)
0168 );
0169 break;
0170 case NDRXD_CALL_TYPE_PM_STOPPING:
0171 fprintf(stderr, "Server executable = %s\tId = %d :\t",
0172 pm_info->binary_name, pm_info->srvid);
0173 break;
0174 case NDRXD_CALL_TYPE_PM_STOPPED:
0175 fprintf(stderr, "%s.\n",
0176 proc_state_to_str(pm_info->state, reply->msg_type)
0177 );
0178 break;
0179 case NDRXD_CALL_TYPE_GENERIC:
0180 if (NDRXD_COM_STOP_RP==reply->command)
0181 fprintf(stderr, "Shutdown finished. %ld processes stopped.\n",
0182 reply->userfld1);
0183 else if (NDRXD_COM_SRELOAD_RP==reply->command)
0184 fprintf(stderr, "Reload finished. %ld processes reloaded.\n",
0185 reply->userfld1);
0186 else
0187 fprintf(stderr, "Startup finished. %ld processes started.\n",
0188 reply->userfld1);
0189 break;
0190 default:
0191 NDRX_LOG(log_error, "Ignoring unknown message!");
0192 break;
0193 }
0194 return EXSUCCEED;
0195 }
0196
0197
0198
0199
0200
0201
0202
0203
0204
0205 expublic int cmd_start(cmd_mapping_t *p_cmd_map, int argc, char **argv, int *p_have_next)
0206 {
0207 int ret=EXSUCCEED;
0208 command_startstop_t call;
0209 short srvid=EXFAIL;
0210 char srvnm[MAXTIDENT+1]={EXEOS};
0211 char procgrp[MAXTIDENT+1]={EXEOS};
0212 short confirm = EXFALSE;
0213 short keep_running_ndrxd;
0214 int ids=0;
0215 short include_lp=EXFALSE;
0216
0217 ncloptmap_t clopt[] =
0218 {
0219 {'i', BFLD_SHORT, (void *)&srvid, 0,
0220 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server ID"},
0221 {'s', BFLD_STRING, (void *)srvnm, sizeof(srvnm),
0222 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server name"},
0223 {'g', BFLD_STRING, (void *)procgrp, sizeof(procgrp),
0224 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Process group"},
0225 {'L', BFLD_SHORT, (void *)&include_lp, 0,
0226 NCLOPT_OPT|NCLOPT_TRUEBOOL,
0227 "Include lock provider of the process group"},
0228 {'y', BFLD_SHORT, (void *)&confirm, 0,
0229 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Confirm"},
0230 {'k', BFLD_SHORT, (void *)&keep_running_ndrxd, 0,
0231 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Keep ndrxd running"},
0232 {0}
0233 };
0234
0235 if (argc>=2 && '-'!=argv[1][0])
0236 {
0237 NDRX_STRCPY_SAFE(srvnm, argv[1]);
0238 }
0239 else
0240 {
0241
0242 if (nstd_parse_clopt(clopt, EXTRUE, argc, argv, EXFALSE))
0243 {
0244 fprintf(stderr, XADMIN_INVALID_OPTIONS_MSG);
0245 EXFAIL_OUT(ret);
0246 }
0247 }
0248
0249 memset(&call, 0, sizeof(call));
0250
0251 if (EXFAIL!=srvid)
0252 {
0253 ids++;
0254 }
0255
0256 if (EXEOS!=srvnm[0])
0257 {
0258 ids++;
0259 }
0260
0261 if (EXEOS!=procgrp[0])
0262 {
0263 ids++;
0264 }
0265
0266 if (ids>1)
0267 {
0268 fprintf(stderr, "-i, -s and -g cannot be combined!\n");
0269 EXFAIL_OUT(ret);
0270 }
0271
0272
0273 if (EXFAIL==srvid && EXEOS==srvnm[0] && EXEOS==procgrp[0] &&
0274 !ndrx_chk_confirm("Are you sure you want to start application?", confirm))
0275 {
0276 EXFAIL_OUT(ret);
0277 }
0278
0279
0280 call.srvid = srvid;
0281 NDRX_STRCPY_SAFE(call.binary_name, srvnm);
0282 NDRX_STRCPY_SAFE(call.procgrp, procgrp);
0283
0284 if (include_lp)
0285 {
0286 call.flags|=NDRXD_CALL_FLAGS_LP2GRP;
0287 }
0288
0289 ret=cmd_generic_listcall(p_cmd_map->ndrxd_cmd, NDRXD_SRC_ADMIN,
0290 NDRXD_CALL_TYPE_GENERIC,
0291 (command_call_t *)&call, sizeof(call),
0292 G_config.reply_queue_str,
0293 G_config.reply_queue,
0294 G_config.ndrxd_q,
0295 G_config.ndrxd_q_str,
0296 argc, argv,
0297 p_have_next,
0298 G_call_args,
0299 EXFALSE,
0300 G_config.listcall_flags);
0301 out:
0302 return ret;
0303 }
0304
0305
0306
0307
0308
0309
0310
0311
0312
0313
0314
0315
0316 expublic int cmd_stop(cmd_mapping_t *p_cmd_map, int argc, char **argv, int *p_have_next)
0317 {
0318 int ret=EXSUCCEED;
0319 command_startstop_t call;
0320 short srvid=EXFAIL;
0321 char srvnm[MAXTIDENT+1]={EXEOS};
0322 char procgrp[MAXTIDENT+1]={EXEOS};
0323 short confirm = EXFALSE;
0324 short keep_running_ndrxd = EXFALSE;
0325 short force_off = EXFALSE;
0326 short dummy;
0327 short keep_lcf=EXFALSE;
0328 pid_t pid = EXFAIL;
0329 int ids=0;
0330 short include_lp=EXFALSE;
0331
0332 ncloptmap_t clopt[] =
0333 {
0334 {'i', BFLD_SHORT, (void *)&srvid, 0,
0335 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server ID"},
0336 {'s', BFLD_STRING, (void *)srvnm, sizeof(srvnm),
0337 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server name"},
0338 {'y', BFLD_SHORT, (void *)&confirm, 0,
0339 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Confirm"},
0340 {'g', BFLD_STRING, (void *)procgrp, sizeof(procgrp),
0341 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Process group"},
0342 {'L', BFLD_SHORT, (void *)&include_lp, 0,
0343 NCLOPT_OPT|NCLOPT_TRUEBOOL,
0344 "Include lock provider of the process group"},
0345 {'c', BFLD_SHORT, (void *)&dummy, 0,
0346 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Left for compatibility"},
0347 {'k', BFLD_SHORT, (void *)&keep_running_ndrxd, 0,
0348 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Keep ndrxd running"},
0349 {'f', BFLD_SHORT, (void *)&force_off, 0,
0350 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Force shutdown"},
0351 {'l', BFLD_SHORT, (void *)&keep_lcf, 0,
0352 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Keep lcf commands"},
0353
0354 {0}
0355 };
0356
0357 if (argc>=2 && '-'!=argv[1][0])
0358 {
0359 NDRX_STRCPY_SAFE(srvnm, argv[1]);
0360 }
0361 else
0362 {
0363
0364 if (nstd_parse_clopt(clopt, EXTRUE, argc, argv, EXFALSE))
0365 {
0366 fprintf(stderr, XADMIN_INVALID_OPTIONS_MSG);
0367 EXFAIL_OUT(ret);
0368 }
0369 }
0370
0371 memset(&call, 0, sizeof(call));
0372
0373 if (EXFAIL!=srvid)
0374 {
0375 ids++;
0376 }
0377
0378 if (EXEOS!=srvnm[0])
0379 {
0380 ids++;
0381 }
0382
0383 if (EXEOS!=procgrp[0])
0384 {
0385 ids++;
0386 }
0387
0388 if (ids>1)
0389 {
0390 fprintf(stderr, "-i, -s and -g cannot be combined!\n");
0391 EXFAIL_OUT(ret);
0392 }
0393
0394 if (EXFAIL!=srvid || EXEOS!=srvnm[0] || EXEOS!=procgrp[0])
0395 {
0396 keep_running_ndrxd = EXTRUE;
0397 }
0398
0399 if (EXFAIL==srvid && EXEOS==srvnm[0] && EXEOS==procgrp[0] &&
0400 !ndrx_chk_confirm("Are you sure you want to stop application?", confirm))
0401 {
0402 EXFAIL_OUT(ret);
0403 }
0404
0405
0406 if (keep_running_ndrxd)
0407 {
0408 call.complete_shutdown = EXFALSE;
0409 }
0410 else
0411 {
0412
0413 call.complete_shutdown = EXTRUE;
0414 }
0415
0416 if (call.complete_shutdown && !is_ndrxd_running(&pid, EXFALSE) && !force_off)
0417 {
0418 fprintf(stderr, "WARNING ! `ndrxd' daemon is in `%s', use -f "
0419 "to force shutdown!\n",
0420 NDRXD_STAT_NOT_STARTED==G_config.ndrxd_stat?"not started":"malfunction");
0421
0422 NDRX_LOG(log_warn, "WARNING ! `ndrxd' daemon is in `%s' state, use -f "
0423 "to force shutdown!\n",
0424 NDRXD_STAT_NOT_STARTED==G_config.ndrxd_stat?"not started":"malfunction");
0425 EXFAIL_OUT(ret);
0426 }
0427
0428 call.srvid = srvid;
0429 NDRX_STRCPY_SAFE(call.binary_name, srvnm);
0430 NDRX_STRCPY_SAFE(call.procgrp, procgrp);
0431 if (include_lp)
0432 {
0433 call.flags|=NDRXD_CALL_FLAGS_LP2GRP;
0434 }
0435
0436 ret=cmd_generic_listcall(p_cmd_map->ndrxd_cmd, NDRXD_SRC_ADMIN,
0437 NDRXD_CALL_TYPE_GENERIC,
0438 (command_call_t *)&call, sizeof(call),
0439 G_config.reply_queue_str,
0440 G_config.reply_queue,
0441 G_config.ndrxd_q,
0442 G_config.ndrxd_q_str,
0443 argc, argv,
0444 p_have_next,
0445 G_call_args,
0446 EXFALSE,
0447 G_config.listcall_flags);
0448
0449
0450 if (call.complete_shutdown && (EXSUCCEED==ret || force_off))
0451 {
0452 NDRX_LOG(log_debug, "About to un-init after shutdown");
0453 un_init(EXTRUE);
0454 NDRX_LOG(log_debug, "Un-init completed (after shutdown)");
0455
0456
0457
0458
0459
0460
0461
0462
0463 if (EXFAIL!=pid)
0464 {
0465
0466 while (EXSUCCEED==kill(pid, 0))
0467 {
0468
0469 usleep(100000);
0470
0471
0472 }
0473
0474 ret = EXSUCCEED;
0475 }
0476 else
0477 {
0478
0479 sleep(1);
0480 }
0481
0482
0483
0484
0485 if (!keep_lcf)
0486 {
0487 ndrx_lcf_reset();
0488 }
0489
0490
0491 ndrx_sg_reset();
0492 }
0493
0494 out:
0495 return ret;
0496 }
0497
0498
0499
0500
0501
0502
0503
0504
0505
0506
0507 expublic int cmd_r(cmd_mapping_t *p_cmd_map, int argc, char **argv, int *p_have_next)
0508 {
0509 int ret=EXSUCCEED;
0510 short srvid=EXFAIL;
0511 char srvnm[MAXTIDENT+1]={EXEOS};
0512 char procgrp[MAXTIDENT+1]={EXEOS};
0513 short confirm = EXFALSE;
0514 short keep_running_ndrxd = EXFALSE;
0515 int ids=0;
0516 short include_lp=EXFALSE;
0517
0518
0519 ncloptmap_t clopt[] =
0520 {
0521 {'i', BFLD_SHORT, (void *)&srvid, 0,
0522 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server ID"},
0523 {'s', BFLD_STRING, (void *)srvnm, sizeof(srvnm),
0524 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server name"},
0525 {'g', BFLD_STRING, (void *)procgrp, sizeof(procgrp),
0526 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Process group"},
0527 {'L', BFLD_SHORT, (void *)&include_lp, 0,
0528 NCLOPT_OPT|NCLOPT_TRUEBOOL,
0529 "Include lock provider of the process group"},
0530 {'y', BFLD_SHORT, (void *)&confirm, 0,
0531 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Confirm"},
0532 {'k', BFLD_SHORT, (void *)&keep_running_ndrxd, 0,
0533 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Keep ndrxd running"},
0534 {0}
0535 };
0536
0537 if (argc>=2 && '-'!=argv[1][0])
0538 {
0539 NDRX_STRCPY_SAFE(srvnm, argv[1]);
0540 }
0541 else
0542 {
0543
0544 if (nstd_parse_clopt(clopt, EXTRUE, argc, argv, EXFALSE))
0545 {
0546 fprintf(stderr, XADMIN_INVALID_OPTIONS_MSG);
0547 EXFAIL_OUT(ret);
0548 }
0549 }
0550
0551 NDRX_LOG(log_info, "Shutting down...");
0552 strcpy(argv[0], "stop");
0553 if (EXSUCCEED==(ret=process_command_buffer(EXFALSE)))
0554 {
0555 if (!keep_running_ndrxd && EXEOS==srvnm[0] && EXFAIL==srvid)
0556 {
0557 sleep(2);
0558 }
0559 NDRX_LOG(log_debug, "Starting up...");
0560 strcpy(argv[0], "start");
0561 ret=process_command_buffer(EXFALSE);
0562 }
0563
0564 out:
0565 return ret;
0566 }
0567
0568
0569
0570
0571
0572
0573
0574
0575
0576
0577 expublic int cmd_cabort(cmd_mapping_t *p_cmd_map, int argc, char **argv, int *p_have_next)
0578 {
0579 command_call_t call;
0580 memset(&call, 0, sizeof(call));
0581 int ret=EXSUCCEED;
0582
0583 if (!chk_confirm_clopt("Are you sure you want to abort app domain start/stop?", argc, argv))
0584 {
0585 ret=EXFAIL;
0586 goto out;
0587 }
0588
0589 ret=cmd_generic_listcall(p_cmd_map->ndrxd_cmd, NDRXD_SRC_ADMIN,
0590 NDRXD_CALL_TYPE_GENERIC,
0591 &call, sizeof(call),
0592 G_config.reply_queue_str,
0593 G_config.reply_queue,
0594 G_config.ndrxd_q,
0595 G_config.ndrxd_q_str,
0596 argc, argv,
0597 p_have_next,
0598 G_call_args,
0599 EXFALSE,
0600 G_config.listcall_flags);
0601 out:
0602 return ret;
0603 }
0604
0605
0606
0607
0608
0609
0610
0611
0612
0613 expublic int cmd_sreload(cmd_mapping_t *p_cmd_map, int argc, char **argv, int *p_have_next)
0614 {
0615 int ret=EXSUCCEED;
0616 command_startstop_t call;
0617 short srvid=EXFAIL;
0618 char srvnm[MAXTIDENT+1]={EXEOS};
0619 char procgrp[MAXTIDENT+1]={EXEOS};
0620 short confirm = EXFALSE;
0621 int ids=0;
0622 short include_lp=EXFALSE;
0623 ncloptmap_t clopt[] =
0624 {
0625 {'i', BFLD_SHORT, (void *)&srvid, 0,
0626 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server ID"},
0627 {'s', BFLD_STRING, (void *)srvnm, sizeof(srvnm),
0628 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Server name"},
0629 {'g', BFLD_STRING, (void *)procgrp, sizeof(procgrp),
0630 NCLOPT_OPT|NCLOPT_HAVE_VALUE, "Process group"},
0631 {'L', BFLD_SHORT, (void *)&include_lp, 0,
0632 NCLOPT_OPT|NCLOPT_TRUEBOOL,
0633 "Include lock provider of the process group"},
0634 {'y', BFLD_SHORT, (void *)&confirm, 0,
0635 NCLOPT_OPT|NCLOPT_TRUEBOOL, "Confirm"},
0636 {0}
0637 };
0638
0639 if (argc>=2 && '-'!=argv[1][0])
0640 {
0641 NDRX_STRCPY_SAFE(srvnm, argv[1]);
0642 }
0643 else
0644 {
0645
0646 if (nstd_parse_clopt(clopt, EXTRUE, argc, argv, EXFALSE))
0647 {
0648 fprintf(stderr, XADMIN_INVALID_OPTIONS_MSG);
0649 EXFAIL_OUT(ret);
0650 }
0651 }
0652
0653 memset(&call, 0, sizeof(call));
0654
0655 if (EXFAIL!=srvid)
0656 {
0657 ids++;
0658 }
0659
0660 if (EXEOS!=srvnm[0])
0661 {
0662 ids++;
0663 }
0664
0665 if (EXEOS!=procgrp[0])
0666 {
0667 ids++;
0668 }
0669
0670 if (ids>1)
0671 {
0672 fprintf(stderr, "-i, -s and -g cannot be combined!\n");
0673 EXFAIL_OUT(ret);
0674 }
0675
0676 if (EXFAIL==srvid && EXEOS==srvnm[0] && EXEOS==procgrp[0] &&
0677 !ndrx_chk_confirm("Are you sure you want to start application?", confirm))
0678 {
0679 EXFAIL_OUT(ret);
0680 }
0681
0682
0683 call.srvid = srvid;
0684 NDRX_STRCPY_SAFE(call.binary_name, srvnm);
0685 NDRX_STRCPY_SAFE(call.procgrp, procgrp);
0686
0687 if (include_lp)
0688 {
0689 call.flags|=NDRXD_CALL_FLAGS_LP2GRP;
0690 }
0691
0692 ret=cmd_generic_listcall(p_cmd_map->ndrxd_cmd, NDRXD_SRC_ADMIN,
0693 NDRXD_CALL_TYPE_GENERIC,
0694 (command_call_t *)&call, sizeof(call),
0695 G_config.reply_queue_str,
0696 G_config.reply_queue,
0697 G_config.ndrxd_q,
0698 G_config.ndrxd_q_str,
0699 argc, argv,
0700 p_have_next,
0701 G_call_args,
0702 EXFALSE,
0703 G_config.listcall_flags);
0704 out:
0705 return ret;
0706 }
0707