options.cc

remote installation server.

	// valid CSA?
	if(CSA_types[i].arch_name == NULL)
	{
		log->Event(LEVEL_ERR, "AddService:parse", 1,
		   "Unknown client system architecture");
		return;
	}

	// assign the info
	serv_ptr = new services_t;
	serv_ptr->csa = CSA_types[i].arch_id;

	// min layer
	ptr = strtok(NULL, ",");
	if(ptr == NULL)
	{
		log->Event(LEVEL_ERR, "AddService:parse", 1,
		   "Invalid service declaration");
		delete serv_ptr;
		return;
	}
	serv_ptr->min_level = atoi(ptr);
	
	// max layer
	ptr = strtok(NULL, ",");
	if(ptr == NULL)
	{
		log->Event(LEVEL_ERR, "AddService:parse", 1,
		   "Invalid service declaration");
		delete serv_ptr;
		return;
	}
	serv_ptr->max_level = atoi(ptr);

	// basename
	ptr = strtok(NULL, ",");
	if(ptr == NULL)
	{
		log->Event(LEVEL_ERR, "AddService:parse", 1,
		   "Invalid service declaration");
		delete serv_ptr;
		return;
	}
	serv_ptr->filebase = new char[strlen(ptr)+1];
	strcpy(serv_ptr->filebase, ptr);

	// menu entry
	ptr = strtok(NULL, "\0");
	if(ptr == NULL)
	{
		log->Event(LEVEL_ERR, "AddService:parse", 1,
		   "Invalid service declaration");
		delete[] serv_ptr->filebase;
		delete serv_ptr;
		return;
	}
	if(strlen(ptr) > 255)
	{
		log->Event(LEVEL_ERR, "AddService:parse", 1,
			"Menu item too long");
		delete[] serv_ptr->filebase;
		delete serv_ptr;
		return;
	}
	serv_ptr->menu_text = new char[strlen(ptr)+1];
	strcpy(serv_ptr->menu_text, ptr);
	if(strcmp(serv_ptr->filebase, "local") == 0)
		serv_ptr->menu_id = 0;
	else
	{
		serv_ptr->menu_id = *key_id;
		(*key_id)++;
	}

	// find the tail of the list
	for(serv_prev=serv_tail=serv_head; serv_tail != NULL;
	 serv_tail=serv_tail->next)
		serv_prev = serv_tail;

	// append + sort out minor faults
	if(serv_tail == serv_prev) // on head
		serv_head = serv_ptr;
	else
		serv_prev->next = serv_ptr;

	// end of list
	serv_ptr->next = NULL;
}


/******************************************************************************
 * GetMTFTPAddr - return the multicast address of the mtftp daemon            *
 ******************************************************************************/
uint32_t
Options::GetMTFTPAddr()
{
	return(mtftp_address);
}


/******************************************************************************
 * GetMTFTPAddr - return the multicast address of the mtftp daemon            *
 ******************************************************************************/
uint32_t
Options::GetDefAddr()
{
	return(default_address);
}


/******************************************************************************
 * GetMTFTPsport - return the multicast server port of the mtftp daemon       *
 ******************************************************************************/
uint16_t
Options::GetMTFTPsport()
{
	return(mtftp_sport);
}


/******************************************************************************
 * GetMTFTPcport - return the multicast client port of the mtftp daemon       *
 ******************************************************************************/
uint16_t
Options::GetMTFTPcport()
{
	return(mtftp_cport);
}


/******************************************************************************
 * GetMenuTimeout - return the amount of time the boot menu is shown for      *
 ******************************************************************************/
uint8_t
Options::GetMenuTimeout()
{
	return(prompt_timeout);
}


/******************************************************************************
 * GetMenuPrompt - return the menu string                                     *
 ******************************************************************************/
char *
Options::GetMenuPrompt()
{
	char *c = new char[strlen(prompt)+1];
	strcpy(c, prompt);
	return(c);
}


/******************************************************************************
 * CheckMenu - check to see if there is a menu item for a specific CSA        *
 ******************************************************************************/
uint16_t
Options::CheckMenu(uint16_t reqcsa)
{
	services_t *serv_ptr;

	serv_ptr = serv_head;
	while(NULL != serv_ptr)
	{
		if(serv_ptr->csa == reqcsa)
			return(serv_ptr->csa);
		serv_ptr = serv_ptr->next;
	}

	return((uint16_t)-1);
}


/******************************************************************************
 * MakeBootMenu - make the option for the boot menu                           *
 ******************************************************************************/
option *
Options::MakeBootMenu(int csa, int *arch_id, int *menu_id)
{
	int i,j;
	uint16_t menu_id_n;
	int count = 0;
	services_t *serv_ptr;
	option *opt = new option;
	opt->len = i = 0;

	// work out how much memory we need
	serv_ptr = serv_head;
	while(NULL != serv_ptr)
	{
		if(serv_ptr->csa == csa)
			opt->len += strlen(serv_ptr->menu_text)+3;
		serv_ptr = serv_ptr->next;
	}

	opt->data = new uint8_t[opt->len];
	
	// copy the menu items
	serv_ptr = serv_head;
	while(NULL != serv_ptr)
	{
		if(serv_ptr->csa == csa)
		{
			menu_id_n = htons(serv_ptr->menu_id);
			memcpy(opt->data+i, &menu_id_n, 2);
			i += 2;

			j = strlen(serv_ptr->menu_text);
			opt->data[i] = j;
			i++;
			memcpy(opt->data+i, serv_ptr->menu_text, j);
			i += j;

			if(0 == count)
			{
				*arch_id = serv_ptr->csa;
				*menu_id = serv_ptr->menu_id;
			}
			count++;
		}
		serv_ptr = serv_ptr->next;
	}
	
	// last check
	if(0 == opt->len)
		return(NULL);
	return(opt);
}


/******************************************************************************
 * GetMinLayer - get the lowest layer for this item                           *
 ******************************************************************************/
uint8_t
Options::GetMinLayer(int arch_id, int menu_id)
{
	services_t *serv_ptr;

	serv_ptr = serv_head;
	while(NULL != serv_ptr)
	{
		if((menu_id == serv_ptr->menu_id) &&
		  (arch_id == serv_ptr->csa))
		  
			break;
		serv_ptr = serv_ptr->next;
	}
	if(NULL == serv_ptr)
		return(0);
	return(serv_ptr->min_level);
}


/******************************************************************************
 * GetMaxLayer - get the highest layer for this item                          *
 ******************************************************************************/
uint8_t
Options::GetMaxLayer(int arch_id, int menu_id)
{
	services_t *serv_ptr;

	serv_ptr = serv_head;
	while(NULL != serv_ptr)
	{
		if((menu_id == serv_ptr->menu_id) &&
		  (arch_id == serv_ptr->csa))
		  
			break;
		serv_ptr = serv_ptr->next;
	}
	if(NULL == serv_ptr)
		return(0);
	return(serv_ptr->max_level);
}


/******************************************************************************
 * MakeFilename - make the boot filename for a specific arch/layer            *
 ******************************************************************************/
char *
Options::MakeFilename(int menu_id, int arch_id, uint8_t layer)
{
	services_t *serv_ptr;
	char *tmpc;
	int i;

	serv_ptr = serv_head;
	while(NULL != serv_ptr)
	{
		if((menu_id == serv_ptr->menu_id) &&
		  (arch_id == serv_ptr->csa))
		  
			break;
		serv_ptr = serv_ptr->next;
	}

	if(NULL == serv_ptr)
		return(NULL);

	if((layer < serv_ptr->min_level) || (serv_ptr->max_level < layer))
		return(NULL);

	// search for the arch name
	for(i=0; i != CSA_types[i].arch_id; i++);
	tmpc = new char[strlen(CSA_types[i].arch_name) +
	  (strlen(serv_ptr->filebase)*2) + 8];
	sprintf(tmpc, "%s/%s/%s.%d", CSA_types[i].arch_name,
	  serv_ptr->filebase, serv_ptr->filebase, layer);

	return(tmpc);
}


/******************************************************************************
 * CheckLayer - see if the layer requested is withing the valid range         *
 ******************************************************************************/
int
Options::CheckLayer(int menu_id, int arch_id, uint8_t layer)
{

	services_t *serv_ptr;

	serv_ptr = serv_head;
	while(NULL != serv_ptr)
	{
		if((menu_id == serv_ptr->menu_id) &&
		  (arch_id == serv_ptr->csa))
		  
			break;
		serv_ptr = serv_ptr->next;
	}
	if(NULL == serv_ptr)
		return(-1);

	if((layer < serv_ptr->min_level) || (serv_ptr->max_level < layer))
		return(-1);

	return(0);
}