Return to control_controller.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / manager / controller

Strongswan

    1: /*
    2:  * Copyright (C) 2007 Martin Willi
    3:  * HSR Hochschule fuer Technik Rapperswil
    4:  *
    5:  * This program is free software; you can redistribute it and/or modify it
    6:  * under the terms of the GNU General Public License as published by the
    7:  * Free Software Foundation; either version 2 of the License, or (at your
    8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
    9:  *
   10:  * This program is distributed in the hope that it will be useful, but
   11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13:  * for more details.
   14:  */
   15: 
   16: #include "control_controller.h"
   17: #include "../manager.h"
   18: #include "../gateway.h"
   19: 
   20: #include <xml.h>
   21: 
   22: #include <library.h>
   23: 
   24: 
   25: typedef struct private_control_controller_t private_control_controller_t;
   26: 
   27: /**
   28:  * private data of the task manager
   29:  */
   30: struct private_control_controller_t {
   31: 
   32: 	/**
   33: 	 * public functions
   34: 	 */
   35: 	control_controller_t public;
   36: 
   37: 	/**
   38: 	 * manager instance
   39: 	 */
   40: 	manager_t *manager;
   41: };
   42: 
   43: /**
   44:  * handle the result of a control operation
   45:  */
   46: static void handle_result(private_control_controller_t *this, fast_request_t *r,
   47: 						  enumerator_t *e)
   48: {
   49: 	enumerator_t *e1;
   50: 	xml_t *xml;
   51: 	char *name, *value;
   52: 	int num = 0;
   53: 
   54: 	if (e)
   55: 	{
   56: 		while (e->enumerate(e, &xml, &name, &value))
   57: 		{
   58: 			if (streq(name, "status"))
   59: 			{
   60: 				if (value && atoi(value) == 0)
   61: 				{
   62: 					r->set(r, "result", "Operation executed successfully:");
   63: 				}
   64: 				else
   65: 				{
   66: 					r->set(r, "result", "Operation failed:");
   67: 				}
   68: 			}
   69: 			else if (streq(name, "log"))
   70: 			{
   71: 				e1 = xml->children(xml);
   72: 				while (e1->enumerate(e1, &xml, &name, &value))
   73: 				{
   74: 					if (streq(name, "item"))
   75: 					{
   76: 						r->setf(r, "log.%d=%s", ++num, value);
   77: 					}
   78: 				}
   79: 				e1->destroy(e1);
   80: 			}
   81: 		}
   82: 		e->destroy(e);
   83: 		r->render(r, "templates/control/result.cs");
   84: 	}
   85: 	else
   86: 	{
   87: 		r->set(r, "title", "Error");
   88: 		r->set(r, "error", "controlling the gateway failed");
   89: 		r->render(r, "templates/error.cs");
   90: 	}
   91: }
   92: 
   93: /**
   94:  * initiate an IKE or CHILD SA
   95:  */
   96: static void initiate(private_control_controller_t *this, fast_request_t *r,
   97: 					 bool ike, char *config)
   98: {
   99: 	gateway_t *gateway;
  100: 	enumerator_t *e;
  101: 
  102: 	r->setf(r, "title=Establishing %s SA %s", ike ? "IKE" : "CHILD", config);
  103: 	gateway = this->manager->select_gateway(this->manager, 0);
  104: 	e = gateway->initiate(gateway, ike, config);
  105: 	handle_result(this, r, e);
  106: }
  107: 
  108: /**
  109:  * terminate an IKE or CHILD SA
  110:  */
  111: static void terminate(private_control_controller_t *this, fast_request_t *r,
  112: 					  bool ike, uint32_t id)
  113: {
  114: 	gateway_t *gateway;
  115: 	enumerator_t *e;
  116: 
  117: 	r->setf(r, "title=Terminate %s SA %d", ike ? "IKE" : "CHILD", id);
  118: 	gateway = this->manager->select_gateway(this->manager, 0);
  119: 	e = gateway->terminate(gateway, ike, id);
  120: 	handle_result(this, r, e);
  121: }
  122: 
  123: METHOD(fast_controller_t, get_name, char*,
  124: 	private_control_controller_t *this)
  125: {
  126: 	return "control";
  127: }
  128: 
  129: METHOD(fast_controller_t, handle, void,
  130: 	private_control_controller_t *this, fast_request_t *request, char *action,
  131: 	char *str, char *p3, char *p4, char *p5)
  132: {
  133: 	if (!this->manager->logged_in(this->manager))
  134: 	{
  135: 		return request->redirect(request, "auth/login");
  136: 	}
  137: 	if (this->manager->select_gateway(this->manager, 0) == NULL)
  138: 	{
  139: 		return request->redirect(request, "gateway/list");
  140: 	}
  141: 	if (action)
  142: 	{
  143: 		uint32_t id;
  144: 
  145: 		if (streq(action, "terminateike"))
  146: 		{
  147: 			if (str && (id = atoi(str)))
  148: 			{
  149: 				return terminate(this, request, TRUE, id);
  150: 			}
  151: 		}
  152: 		if (streq(action, "terminatechild"))
  153: 		{
  154: 			if (str && (id = atoi(str)))
  155: 			{
  156: 				return terminate(this, request, FALSE, id);
  157: 			}
  158: 		}
  159: 		if (streq(action, "initiateike"))
  160: 		{
  161: 			if (str)
  162: 			{
  163: 				return initiate(this, request, TRUE, str);
  164: 			}
  165: 		}
  166: 		if (streq(action, "initiatechild"))
  167: 		{
  168: 			if (str)
  169: 			{
  170: 				return initiate(this, request, FALSE, str);
  171: 			}
  172: 		}
  173: 	}
  174: 	return request->redirect(request, "ikesa/list");
  175: }
  176: 
  177: METHOD(fast_controller_t, destroy, void,
  178: 	private_control_controller_t *this)
  179: {
  180: 	free(this);
  181: }
  182: 
  183: /*
  184:  * see header file
  185:  */
  186: fast_controller_t *control_controller_create(fast_context_t *context,
  187: 											 void *param)
  188: {
  189: 	private_control_controller_t *this;
  190: 
  191: 	INIT(this,
  192: 		.public = {
  193: 			.controller = {
  194: 				.get_name = _get_name,
  195: 				.handle = _handle,
  196: 				.destroy = _destroy,
  197: 			},
  198: 		},
  199: 		.manager = (manager_t*)context,
  200: 	);
  201: 
  202: 	return &this->public.controller;
  203: }