}else if (strcmp(output, "Not Available") == 0	|| strcmp(output, "Error") == 0) {		state = STATE_INVALID;	}	FREE(output);	output = NULL;	if (state == STATE_INVALID) {		PILCallLog(LOG, PIL_CRIT, "host %s in invalid state", host);		return S_OOPS;	}	switch (request) {	case ST_GENERIC_RESET:		if (dev->hmcver < 4) {			if (is_lpar) {				if (state == STATE_ON) {					output = do_shell_cmd(off_cmd, &status);					if (0 != status) {						PILCallLog(LOG, PIL_CRIT						,	"command %s failed"						,	off_cmd);						return S_OOPS;					}				}				for (i = 0; i < MAX_POWERON_RETRY; i++) {					char *output2;					output2 = do_shell_cmd(on_cmd, &status);					if (output2 != NULL) {						FREE(output2);					}					if (0 != status) {						sleep(1);					}else{						break;					}				}				if (MAX_POWERON_RETRY == i) {					PILCallLog(LOG, PIL_CRIT					,	"command %s failed"					,	on_cmd);					return S_OOPS;				}			}else{				output = do_shell_cmd(reset_cmd, &status);				if (0 != status) {					PILCallLog(LOG, PIL_CRIT					,	"command %s failed"					,	reset_cmd);					return S_OOPS;				}				break;			}		}else{			if (state == STATE_ON) {				output = do_shell_cmd(reset_cmd, &status);			}else{				output = do_shell_cmd(on_cmd, &status);			}			if (0 != status) {				PILCallLog(LOG, PIL_CRIT				,	"command %s failed", reset_cmd);				return S_OOPS;			}		}		break;	default:		return S_INVAL;	}	if (output != NULL) {		FREE(output);	}	PILCallLog(LOG, PIL_INFO, "Host %s %s %d."	,	host, __FUNCTION__, request);	return S_OK;}/* *	Parse the information in the given configuration file, *	and stash it away... */static intibmhmc_set_config_file(Stonith* s, const char * configname){	FILE* cfgfile = NULL;	struct HMCDevice* dev = NULL;	char hostline[MAX_HOST_NAME_LEN];		if (!ISHMCDEV(s)) {		PILCallLog(LOG, PIL_CRIT, "invalid argument to %s"		,	__FUNCTION__);		return(S_OOPS);	}	dev = (struct HMCDevice*) s->pinfo;	cfgfile = fopen(configname, "r");	if (cfgfile == NULL)  {		PILCallLog(LOG, PIL_CRIT, "Cannot open %s", configname);		return(S_BADCONFIG);	}	while (fgets(hostline, sizeof(hostline), cfgfile) != NULL){		if (*hostline == '#' || *hostline == '\n' || *hostline == EOS){			continue;		}		return ibmhmc_parse_config_info(dev, hostline);	}	return S_BADCONFIG;}/* *	Parse the config information in the given string, and stash it away... */static intibmhmc_set_config_info(Stonith* s, const char * info){	struct HMCDevice* dev;	if (!ISHMCDEV(s)) {		PILCallLog(LOG, PIL_CRIT, "%s: invalid argument", __FUNCTION__);		return(S_OOPS);	}	dev = (struct HMCDevice *)s->pinfo;	return(ibmhmc_parse_config_info(dev, info));}static const char*ibmhmc_getinfo(Stonith* s, int reqtype){	struct HMCDevice* dev;	const char* ret;	if (!ISHMCDEV(s)) {		PILCallLog(LOG, PIL_CRIT, "HMC_idinfo: invalid argument");		return NULL;	}	dev = (struct HMCDevice *)s->pinfo;	switch (reqtype) {		case ST_DEVICEID:			ret = _("IBM HMC Device");			break;		case ST_CONF_INFO_SYNTAX:			ret = _("ipaddr [managedsyspat]...");			break;		case ST_CONF_FILE_SYNTAX:			ret = _("ipaddr [managedsyspat]...\n"			"All items must be on one line. "			"Blank lines and lines beginning with # are ignored");			break;		case ST_DEVICEDESCR:			ret = _("IBM Hardware Management Console (HMC)\n"			"Use for IBM i5, p5, pSeries and OpenPower systems "			"managed by HMC\n"			"Optional parameter(s) after ipaddr is/are a "			"white-space delimited list of patterns used to match "			"managed system names; if last character is '*', all "			"names that begin with the pattern are matched\n"			" See " HMCURL " for more information.");			break;		default:			ret = NULL;			break;	}	return ret;}/* *	HMC Stonith destructor... */static voidibmhmc_destroy(Stonith *s){	struct HMCDevice* dev;	if (!ISHMCDEV(s)) {		PILCallLog(LOG, PIL_CRIT, "%s: invalid argument", __FUNCTION__);		return;	}	dev = (struct HMCDevice *)s->pinfo;	dev->HMCid = NOTibmhmcID;	if (dev->hmc) {		FREE(dev->hmc);		dev->hmc = NULL;	}	free_hmc_hostlist(dev);	free_hmc_mansyspats(dev);	FREE(dev);}static void *ibmhmc_new(void){	struct HMCDevice* dev = MALLOCT(struct HMCDevice);	if (dev == NULL) {		PILCallLog(LOG, PIL_CRIT, "out of memory");		return(NULL);	}	memset(dev, 0, sizeof(*dev));	dev->HMCid = HMCid;	dev->hostlist = NULL;	dev->hmc = NULL;	dev->mansyspats = NULL;	dev->hmcver = -1;	return((void *)dev);}static intget_hmc_hostlist(struct HMCDevice* dev){	int i, j, status;	char* output = NULL;	char get_syslist[MAX_CMD_LEN];	char host[MAX_HOST_NAME_LEN];	gchar** syslist = NULL;	gchar** name_mode = NULL;	char get_lpar[MAX_CMD_LEN];	gchar** lparlist = NULL;	if(Debug){		PILCallLog(LOG, PIL_DEBUG, "%s: called, dev->hmc=%s\n"		,	__FUNCTION__, dev->hmc);	}	if (dev->hmc == NULL || *dev->hmc == 0){		return S_BADCONFIG;	}		/* get the managed system's names of the hmc */	if (dev->hmcver < 4) {		snprintf(get_syslist, MAX_CMD_LEN, SSH_CMD " -l " HMCROOT			" %s lssyscfg -r sys -F name:mode --all", dev->hmc);	}else{		snprintf(get_syslist, MAX_CMD_LEN, SSH_CMD 			" -l " HMCROOT " %s lssyscfg -r sys -F name", dev->hmc);	}	if(Debug){		PILCallLog(LOG, PIL_DEBUG, "%s: get_syslist=%s"		,	__FUNCTION__, get_syslist);	}	output = do_shell_cmd(get_syslist, &status);	if (output == NULL) {		return S_BADCONFIG;	}			syslist = g_strsplit(output, "\n", 0);	FREE(output);	/* for each managed system */	for (i = 0; syslist[i] != NULL && syslist[i][0] != 0; i++) {		if (dev->hmcver < 4) {			name_mode = g_strsplit(syslist[i], ":", 2);			if(Debug){			PILCallLog(LOG, PIL_DEBUG			,	"%s: name_mode0=%s, name_mode1=%s\n"			,	__FUNCTION__, name_mode[0], name_mode[1]);			}			if (dev->mansyspats != NULL			&& !pattern_match(dev->mansyspats, name_mode[0])) {				continue;			}			/* if it is in fullsystempartition */			if (NULL != name_mode[1]			&& 0 == strncmp(name_mode[1], "0", 1)) {				/* add the FullSystemPartition */				snprintf(host, MAX_HOST_NAME_LEN				,	"%s/FullSystemPartition", name_mode[0]);				dev->hostlist = g_list_append(dev->hostlist 				,	STRDUP(host));			}else if (NULL != name_mode[1]			&& 0 == strncmp(name_mode[1], "255", 3)){				/* get its lpars */				snprintf(get_lpar, MAX_CMD_LEN				,	SSH_CMD " -l " HMCROOT				" %s lssyscfg -m %s -r lpar -F name --all"				,	dev->hmc, name_mode[0]);				if(Debug){					PILCallLog(LOG, PIL_DEBUG					,	"%s: get_lpar=%s\n"					,	__FUNCTION__, get_lpar);				}				output = do_shell_cmd(get_lpar, &status);				if (output == NULL) {					g_strfreev(name_mode);					g_strfreev(syslist);					return S_BADCONFIG;				}						lparlist = g_strsplit(output, "\n", 0);				FREE(output);					/* for each lpar */				for (j = 0				; NULL != lparlist[j] && 0 != lparlist[j][0]				; j++) {					/* skip the full system partition */					if (0 == strncmp(lparlist[j]					,	FULLSYSTEMPARTITION					,	strlen(FULLSYSTEMPARTITION))) {						continue;					}					/* add the lpar */					snprintf(host, MAX_HOST_NAME_LEN					,	"%s/%s", name_mode[0]					,	lparlist[j]);					dev->hostlist = 						g_list_append(dev->hostlist						,	STRDUP(host));				}				g_strfreev(lparlist);			}			g_strfreev(name_mode);		}else{			if (dev->mansyspats != NULL			&& !pattern_match(dev->mansyspats, syslist[i])) {				continue;			}			/* get its lpars */			snprintf(get_lpar, MAX_CMD_LEN			,	SSH_CMD " -l " HMCROOT				 " %s lssyscfg -m %s -r lpar -F name"			,	dev->hmc, syslist[i]);			if(Debug){				PILCallLog(LOG, PIL_DEBUG, "%s: get_lpar=%s\n"				,	__FUNCTION__, get_lpar);			}			output = do_shell_cmd(get_lpar, &status);			if (output == NULL) {				g_strfreev(syslist);				return S_BADCONFIG;			}					lparlist = g_strsplit(output, "\n", 0);			FREE(output);			/* for each lpar */			for (j = 0			; NULL != lparlist[j] && 0 != lparlist[j][0]			; j++) {				/* add the lpar */				snprintf(host, MAX_HOST_NAME_LEN				,	"%s/%s", syslist[i],lparlist[j]);				dev->hostlist = g_list_append(dev->hostlist						,	STRDUP(host));			}			g_strfreev(lparlist);		}	}	g_strfreev(syslist);		return S_OK;}static voidfree_hmc_hostlist(struct HMCDevice* dev){	if (dev->hostlist) {		GList* node;		while (NULL != (node=g_list_first(dev->hostlist))) {			dev->hostlist = g_list_remove_link(dev->hostlist, node);			FREE(node->data);			g_list_free(node);		}		dev->hostlist = NULL;	}}static intget_hmc_mansyspats(struct HMCDevice * dev, const char *mansyspats){	char *patscopy;	int numpats;		int i;	char *tmp;	if(Debug){		PILCallLog(LOG, PIL_DEBUG, "%s: called, mansyspats=%s\n"		,	__FUNCTION__, mansyspats);	}		patscopy = STRDUP(mansyspats);	if (patscopy == NULL) {		PILCallLog(LOG, PIL_CRIT, "%s: out of memory", __FUNCTION__);		return S_OOPS;	}	numpats = get_num_tokens(patscopy);		if (numpats > 0) {		dev->mansyspats = MALLOC((numpats+1)*sizeof(char *));		if (dev->mansyspats == NULL) {			PILCallLog(LOG, PIL_CRIT, "%s: out of memory"			,	__FUNCTION__);			FREE(patscopy);			return S_OOPS;		}		memset(dev->mansyspats, 0, (numpats+1)*sizeof(char *));		/* White-space split the output here */		i = 0;		tmp = strtok(patscopy, WHITESPACE);		while (tmp != NULL) {			dev->mansyspats[i] = STRDUP(tmp);			if (dev->mansyspats[i] == NULL) {				PILCallLog(LOG, PIL_CRIT, "%s: out of memory"				,	__FUNCTION__);				free_hmc_mansyspats(dev);				dev->mansyspats = NULL;				FREE(patscopy);				return S_OOPS;			}				if(Debug){				PILCallLog(LOG, PIL_DEBUG				,	"%s: adding pattern %s\n"				,	__FUNCTION__, dev->mansyspats[i]);			}			/* no patterns necessary if all specified */			if (strcmp(dev->mansyspats[i], "*") == 0) {				ibmhmc_free_hostlist(dev->mansyspats);				dev->mansyspats = NULL;				break;			}			i++;			tmp = strtok(NULL, WHITESPACE);		}	}	FREE(patscopy);	return S_OK;}static voidfree_hmc_mansyspats(struct HMCDevice* dev){	if (dev->mansyspats) {		ibmhmc_free_hostlist(dev->mansyspats);		dev->mansyspats = NULL;	}}static char*do_shell_cmd(const char* cmd, int* status){	const int BUFF_LEN=4096;	int read_len = 0;	char buff[BUFF_LEN];	char* data = NULL;	GString* g_str_tmp = NULL;	FILE* file = popen(cmd, "r");	if (NULL == file) {		return NULL;	}	g_str_tmp = g_string_new("");	while(!feof(file)) {		memset(buff, 0, BUFF_LEN);		read_len = fread(buff, 1, BUFF_LEN, file);		if (0 < read_len) {			g_string_append(g_str_tmp, buff);		}else{			sleep(1);		}	}	data = (char*)MALLOC(g_str_tmp->len+1);	data[0] = data[g_str_tmp->len] = 0;	strncpy(data, g_str_tmp->str, g_str_tmp->len);	g_string_free(g_str_tmp, TRUE);	*status = pclose(file);	return data;}static intcheck_hmc_status(const char* hmc){	int status;	char check_status[MAX_CMD_LEN];	char* output = NULL;	int rc = S_OK;	if(Debug){		PILCallLog(LOG, PIL_DEBUG, "%s: called, hmc=%s\n"		,	__FUNCTION__, hmc);	}	snprintf(check_status, MAX_CMD_LEN	,	SSH_CMD " -l " HMCROOT " %s lshmc -r -F ssh", hmc);	if(Debug){		PILCallLog(LOG, PIL_DEBUG, "%s: check_status %s\n"		,	__FUNCTION__, check_status);	}	output = do_shell_cmd(check_status, &status);	if (Debug) {		PILCallLog(LOG, PIL_DEBUG, "%s: status=%d, output=%s\n"		,	__FUNCTION__, status, output ? output : "(nil)");	}	if (NULL == output || strncmp(output, "enable", 6) != 0) {		rc = S_BADCONFIG;	}	if (NULL != output) {		FREE(output);	}	return rc;}static intget_num_tokens(char *str){	int namecount = 0;	while (*str != EOS) {		str += strspn(str, WHITESPACE);		if (*str == EOS)			break;		str += strcspn(str, WHITESPACE);		namecount++;	}	return namecount;}static gbooleanpattern_match(char **patterns, char *string){	char **pattern;	if(Debug){		PILCallLog(LOG, PIL_DEBUG, "%s: called, string=%s\n"		,	__FUNCTION__, string);	}	for (pattern = patterns; *pattern; pattern++) {		int patlen = strlen(*pattern);		if (pattern[0][patlen-1] == '*') {			/* prefix match */			if (strncmp(string, *pattern, patlen-1) == 0) {				return TRUE;			}		}else{			/* exact match */			if (strcmp(string, *pattern) == 0) {				return TRUE;			}		}	}	return FALSE;}