policy.cgi

xen 3.2.2 源码

				continue

			steTypes = getSteTypes( domNode )
			if steTypes == None:
				msg = ''
				msg = msg + 'Error processing the SimpleTypeEnforcement types.\n'
				msg = msg + 'Please validate the Policy file used.'
				formatXmlError( msg )
				return

			newRes( resName, 1 )
			allResStes[resName][1] = steTypes

def modFormTemplate( formTemplate, suffix ):
	formVar = [x for x in formTemplate]

	if formVar[2] != '':
		formVar[2] = formVar[2] + suffix
	if formVar[3] != '':
		formVar[3] = formVar[3] + suffix
	if (formVar[0] != 'button') and (formVar[4] != ''):
		formVar[4] = formVar[4] + suffix

	return formVar;

def removeDups( curList ):
	newList = []
	curSet  = Set( curList )
	for x in curSet:
		newList.append( x )
	newList.sort( )

	return newList

def newCS( csName, addToList = 0 ):
	global formCSNames
	global templateCSDel, allCSDel
	global templateCSMTypes, templateCSMDel, templateCSMType, templateCSMAdd
	global allCSMTypes, allCSMDel, allCSMType, allCSMAdd

	csSuffix = '_' + csName

	# Make sure we have an actual name and check one of the 'all'
	# variables to be sure it hasn't been previously defined
	if (len( csName ) > 0) and (not allCSMTypes.has_key( csName )):
		allCSDel[csName]    = modFormTemplate( templateCSDel,    csSuffix )
		allCSMTypes[csName] = modFormTemplate( templateCSMTypes, csSuffix )
		allCSMDel[csName]   = modFormTemplate( templateCSMDel,   csSuffix )
		allCSMType[csName]  = modFormTemplate( templateCSMType,  csSuffix )
		allCSMAdd[csName]   = modFormTemplate( templateCSMAdd,   csSuffix )
		if addToList == 1:
			formCSNames[1].append( csName )
			formCSNames[1] = removeDups( formCSNames[1] )

def newVm( vmName, addToList = 0 ):
	global formVmNames
	global templateVmDel, allVmDel, templateVmDom0, allVmDom0
	global templateVmChWs, templateVmChWDel, templateVmChW, templateVmChWAdd
	global allVmChWs, allVmChWDel, allVmChWType, allVmChWAdd
	global templateVmStes, templateVmSteDel, templateVmSte, templateVmSteAdd
	global allVmStes, allVmSteDel, allVmSteType, allVmSteAdd

	# Make sure we have an actual name and check one of the 'all'
	# variables to be sure it hasn't been previously defined
	if (len( vmName ) > 0) and (not allVmDom0.has_key( vmName )):
		vmSuffix = '_' + vmName
		allVmDom0[vmName]   = modFormTemplate( templateVmDom0,   vmSuffix )
		allVmDel[vmName]    = modFormTemplate( templateVmDel,    vmSuffix )
		allVmChWs[vmName]   = modFormTemplate( templateVmChWs,   vmSuffix )
		allVmChWDel[vmName] = modFormTemplate( templateVmChWDel, vmSuffix )
		allVmChW[vmName]    = modFormTemplate( templateVmChW,    vmSuffix )
		allVmChWAdd[vmName] = modFormTemplate( templateVmChWAdd, vmSuffix )
		allVmStes[vmName]   = modFormTemplate( templateVmStes,   vmSuffix )
		allVmSteDel[vmName] = modFormTemplate( templateVmSteDel, vmSuffix )
		allVmSte[vmName]    = modFormTemplate( templateVmSte,    vmSuffix )
		allVmSteAdd[vmName] = modFormTemplate( templateVmSteAdd, vmSuffix )
		if addToList == 1:
			formVmNames[1].append( vmName )
			formVmNames[1] = removeDups( formVmNames[1] )

def newRes( resName, addToList = 0 ):
	global formResNames
	global templateResDel, allResDel
	global templateResStes, templateResSteDel, templateResSte, templateResSteAdd
	global allResStes, allResSteDel, allResSteType, allResSteAdd

	# Make sure we have an actual name and check one of the 'all'
	# variables to be sure it hasn't been previously defined
	if (len( resName ) > 0) and (not allResDel.has_key( resName )):
		resSuffix = '_' + resName
		allResDel[resName]    = modFormTemplate( templateResDel,    resSuffix )
		allResStes[resName]   = modFormTemplate( templateResStes,   resSuffix )
		allResSteDel[resName] = modFormTemplate( templateResSteDel, resSuffix )
		allResSte[resName]    = modFormTemplate( templateResSte,    resSuffix )
		allResSteAdd[resName] = modFormTemplate( templateResSteAdd, resSuffix )
		if addToList == 1:
			formResNames[1].append( resName )
			formResNames[1] = removeDups( formResNames[1] )

def updateInfo( ):
	global formData, formPolicyName, formPolicyUrl, formPolicyRef, formPolicyDate, formPolicyNSUrl
	global formPolicyOrder

	if formData.has_key( formPolicyName[3] ):
		formPolicyName[1] = formData[formPolicyName[3]].value
	elif formData.has_key( formPolicyUpdate[3] ):
		formPolicyName[1] = ''

	if formData.has_key( formPolicyUrl[3] ):
		formPolicyUrl[1] = formData[formPolicyUrl[3]].value
	elif formData.has_key( formPolicyUpdate[3] ):
		formPolicyUrl[1] = ''

	if formData.has_key( formPolicyRef[3] ):
		formPolicyRef[1] = formData[formPolicyRef[3]].value
	elif formData.has_key( formPolicyUpdate[3] ):
		formPolicyRef[1] = ''

	if formData.has_key( formPolicyDate[3] ):
		formPolicyDate[1] = formData[formPolicyDate[3]].value
	elif formData.has_key( formPolicyUpdate[3] ):
		formPolicyDate[1] = ''

	if formData.has_key( formPolicyNSUrl[3] ):
		formPolicyNSUrl[1] = formData[formPolicyNSUrl[3]].value
	elif formData.has_key( formPolicyUpdate[3] ):
		formPolicyNSUrl[1] = ''

	if formData.has_key( formPolicyOrder[3] ):
		formPolicyOrder[1] = formData[formPolicyOrder[3]].value

def addSteType( ):
	global formData, formSteType, formSteTypes

	if (formData.has_key( formDefaultButton[3] )) or (formData.has_key( formSteAdd[3] )):
		if formData.has_key( formSteType[3] ):
			type = formData[formSteType[3]].value
			type = type.strip( )
			if len( type ) > 0:
				formSteTypes[1].append( type )
				formSteTypes[1] = removeDups( formSteTypes[1] )


def delSteType( ):
	global formData, formSteTypes

	if formData.has_key( formSteTypes[3] ):
		typeList = formData.getlist( formSteTypes[3] )
		for type in typeList:
			type = type.strip( )
			formSteTypes[1].remove( type )

def addChWallType( ):
	global formData, formChWallType, formChWallTypes

	if (formData.has_key( formDefaultButton[3] )) or (formData.has_key( formChWallAdd[3] )):
		if formData.has_key( formChWallType[3] ):
			type = formData[formChWallType[3]].value
			type = type.strip( )
			if len( type ) > 0:
				formChWallTypes[1].append( type )
				formChWallTypes[1] = removeDups( formChWallTypes[1] )

def delChWallType( ):
	global formData, formChWallTypes

	if formData.has_key( formChWallTypes[3] ):
		typeList = formData.getlist( formChWallTypes[3] )
		for type in typeList:
			type = type.strip( )
			formChWallTypes[1].remove( type )

def addCS( ):
	global formData, formCSNames

	if (formData.has_key( formDefaultButton[3] )) or (formData.has_key( formCSAdd[3] )):
		if formData.has_key( formCSName[3] ):
			csName = formData[formCSName[3]].value
			csName = csName.strip( )
			newCS( csName, 1 )

def delCS( csName ):
	global formData, formCSNames, allCSDel
	global allCSMTypes, allCSMDel, allCSMType, allCSMAdd

	csName = csName.strip( )
	formCSNames[1].remove( csName )
	del allCSDel[csName]
	del allCSMTypes[csName]
	del allCSMDel[csName]
	del allCSMType[csName]
	del allCSMAdd[csName]

def addCSMember( csName ):
	global formData, allCSMType, allCSMTypes

	formVar = allCSMType[csName]
	if formData.has_key( formVar[3] ):
		csmList = formData.getlist( formVar[3] )
		formVar = allCSMTypes[csName]
		for csm in csmList:
			csm = csm.strip( )
			formVar[1].append( csm )
			formVar[1] = removeDups( formVar[1] )

def delCSMember( csName ):
	global formData, allCSMTypes

	formVar = allCSMTypes[csName]
	if formData.has_key( formVar[3] ):
		csmList = formData.getlist( formVar[3] )
		for csm in csmList:
			csm = csm.strip( )
			formVar[1].remove( csm )

def addVm( ):
	global formData, fromVmName, formVmNames, formVmNameDom0

	if (formData.has_key( formDefaultButton[3] )) or (formData.has_key( formVmAdd[3] )):
		if formData.has_key( formVmName[3] ):
			vmName = formData[formVmName[3]].value
			vmName = vmName.strip( )
			newVm( vmName, 1 )
			if formVmNameDom0[1] == '':
				formVmNameDom0[1] = vmName

def delVm( vmName ):
	global formVmNames, formVmNameDom0
	global allVmDel, allVmDom0
	global allVmChWs, allVmChWDel, allVmChWType, allVmChWAdd
	global allVmStes, allVmSteDel, allVmSteType, allVmSteAdd

	vmName = vmName.strip( )
	formVmNames[1].remove( vmName )
	del allVmDom0[vmName]
	del allVmDel[vmName]
	del allVmChWs[vmName]
	del allVmChWDel[vmName]
	del allVmChW[vmName]
	del allVmChWAdd[vmName]
	del allVmStes[vmName]
	del allVmSteDel[vmName]
	del allVmSte[vmName]
	del allVmSteAdd[vmName]

	if formVmNameDom0[1] == vmName:
		if len( formVmNames[1] ) > 0:
			formVmNameDom0[1] = formVmNames[1][0]
		else:
			formVmNameDom0[1] = ''

def makeVmDom0( vmName ):
	global formVmNameDom0

	vmName = vmName.strip( )
	formVmNameDom0[1] = vmName

def addVmChW( vmName ):
	global formData, allVmChW, allVmChWs

	formVar = allVmChW[vmName]
	if formData.has_key( formVar[3] ):
		chwList = formData.getlist( formVar[3] )
		formVar = allVmChWs[vmName]
		for chw in chwList:
			chw = chw.strip( )
			formVar[1].append( chw )
			formVar[1] = removeDups( formVar[1] )

def delVmChW( vmName ):
	global formData, allVmChWs

	formVar = allVmChWs[vmName]
	if formData.has_key( formVar[3] ):
		chwList = formData.getlist( formVar[3] )
		for chw in chwList:
			chw = chw.strip( )
			formVar[1].remove( chw )

def addVmSte( vmName ):
	global formData, allVmSte, allVmStes

	formVar = allVmSte[vmName]
	if formData.has_key( formVar[3] ):
		steList = formData.getlist( formVar[3] )
		formVar = allVmStes[vmName]
		for ste in steList:
			ste = ste.strip( )
			formVar[1].append( ste )
			formVar[1] = removeDups( formVar[1] )

def delVmSte( vmName ):
	global formData, allVmStes

	formVar = allVmStes[vmName]
	if formData.has_key( formVar[3] ):
		steList = formData.getlist( formVar[3] )
		for ste in steList:
			ste = ste.strip( )
			formVar[1].remove( ste )

def addRes( ):
	global formData, fromResName, formResNames

	if (formData.has_key( formDefaultButton[3] )) or (formData.has_key( formResAdd[3] )):
		if formData.has_key( formResName[3] ):
			resName = formData[formResName[3]].value
			resName = resName.strip( )
			newRes( resName, 1 )

def delRes( resName ):
	global formResNames
	global allResDel
	global allResStes, allResSteDel, allResSteType, allResSteAdd

	resName = resName.strip( )
	formResNames[1].remove( resName )
	del allResDel[resName]
	del allResStes[resName]
	del allResSteDel[resName]
	del allResSte[resName]
	del allResSteAdd[resName]

def addResSte( vmName ):
	global formData, allResSte, allResStes

	formVar = allResSte[vmName]
	if formData.has_key( formVar[3] ):
		steList = formData.getlist( formVar[3] )
		formVar = allResStes[vmName]
		for ste in steList:
			ste = ste.strip( )
			formVar[1].append( ste )
			formVar[1] = removeDups( formVar[1] )

def delResSte( vmName ):
	global formData, allResStes

	formVar = allResStes[vmName]
	if formData.has_key( formVar[3] ):
		steList = formData.getlist( formVar[3] )
		for ste in steList:
			ste = ste.strip( )
			formVar[1].remove( ste )

def processRequest( ):
	global policyXml
	global formData, formPolicyUpdate
	global formSteAdd, formSteDel
	global formChWallAdd, formChWallDel
	global formCSAdd, allCSDel
	global formCSNames, allCSMAdd, allCSMDel
	global formVmAdd
	global formVmNames, allVmDel, allVmDom0
	global allVmChWAdd, allVmChWDel, allVmSteAdd, allVmSteDel
	global formResAdd
	global formResNames, allResDel
	global allResSteAdd, allResSteDel

	if policyXml != '':
		parsePolicyXml( )

	# Allow the updating of the header information whenever
	# an action is performed
	updateInfo( )

	# Allow the adding of types/sets/vms if the user has hit the
	# enter key when attempting to add a type/set/vm
	addSteType( )
	addChWallType( )
	addCS( )
	addVm( )
	addRes( )

	if formData.has_key( formSteDel[3] ):
		delSteType( )

	elif formData.has_key( formChWallDel[3] ):
		delChWallType( )

	else:
		for csName in formCSNames[1]:
			if formData.has_key( allCSDel[csName][3] ):
				delCS( csName )
				continue

			if formData.has_key( allCSMAdd[csName][3] ):
				addCSMember( csName )

			elif formData.has_key( allCSMDel[csName][3] ):
				delCSMember( csName )

	for vmName in formVmNames[1]:
		if formData.has_key( allVmDel[vmName][3] ):
			delVm( vmName )
			continue

		if formData.has_key( allVmDom0[vmName][3] ):
			makeVmDom0( vmName )

		if formData.has_key( allVmChWAdd[vmName][3] ):
			addVmChW( vmName )

		elif formData.has_key( allVmChWDel[vmName][3] ):
			delVmChW( vmName )

		elif formData.has_key( allVmSteAdd[vmName][3] ):
			addVmSte( vmName )

		elif formData.has_key( allVmSteDel[vmName][3] ):
			delVmSte( vmName )

	for resName in formResNames[1]:
		if formData.has_key( allResDel[resName][3] ):
			delRes( resName )
			continue

		if formData.has_key( allResSteAdd[resName][3] ):
			addResSte( resName )

		elif formData.has_key( allResSteDel[resName][3] ):
			delResSte( resName )

def makeName( name, suffix='' ):
	rName = name
	if suffix != '':
		rName = rName + '_' + suffix

	return rName

def makeNameAttr( name, suffix='' ):
	return 'name="' + makeName( name, suffix ) + '"'

def makeValue( value, suffix='' ):
	rValue = value

	if isinstance( value, list ):
		rValue = '['
		for val in value:
			rValue = rValue + '\'' + val
			if suffix != '':
				rValue = rValue + '_' + suffix
			rValue = rValue + '\','
		rValue = rValue + ']'

	else:
		if suffix != '':
			rValue = rValue + '_' + suffix

	return rValue

def makeValueAttr( value, suffix='' ):
	return 'value="' + makeValue( value, suffix ) + '"'

def sendHtmlFormVar( formVar, attrs='', rb_select=0 ):
	nameAttr  = ''
	valueAttr = ''
	htmlText  = ''

	if formVar[0] == 'text':
		if formVar[3] != '':
			nameAttr = makeNameAttr( formVar[3] )
		valueAttr = makeValueAttr( formVar[1] )

		print '<INPUT type="text"', nameAttr, valueAttr, attrs, '>'

	elif formVar[0] == 'list':
		if formVar[3] != '':
			nameAttr = makeNameAttr( formVar[3] )

		print '<SELECT', nameAttr, attrs, '>'
		for option in formVar[1]:
			print '<OPTION>' + option + '</OPTION>'
		print '</SELECT>'

	elif formVar[0] == 'button':