lock_file_f = fopen(lock_file, "w+");

			if (lock_file_f == NULL) {

				std::cerr << "Cannot create lock file " << lock_file << ". Exiting\n";

				exit(1);

			}

			sprintf(process_pid,"%d\n",pid);

			if (fwrite(process_pid,1,strlen(process_pid),lock_file_f) < strlen(process_pid)) {

				std::cerr << "Cannot write to lock file " << lock_file << ". Exiting\n";

				exit(1);

			}

			fclose(lock_file_f);

		}

		exit(0);

	}

	/* Change the file mode mask */

	umask(0);

	/* Create a new SID for the child process */

	sid = setsid();

	if (sid < 0) {

		exit(1);

	}

	/* Change the current working directory.  This prevents the current

		directory from being locked; hence not being able to remove it. */

	if ((chdir(cwd)) < 0) {

		exit(1);

	}

	if (freopen( "/dev/null", "r", stdin) == NULL) {

		std::cout << "EE cannot open /dev/null. Exiting\n";

		exit(1);

	}

}

#endif

int main(int argc, char **argv)

{

	Config config(argc, argv);

	boost::program_options::variables_map vm;

	bool no_daemon = false;

	std::string config_file;

	std::string jid;

	setlocale(LC_ALL, "");

#ifndef WIN32

	if (signal(SIGINT, spectrum_sigint_handler) == SIG_ERR) {

		std::cout << "SIGINT handler can't be set\n";

		return -1;

	}

	if (signal(SIGTERM, spectrum_sigterm_handler) == SIG_ERR) {

		std::cout << "SIGTERM handler can't be set\n";

		return -1;

	}

#endif

	boost::program_options::options_description desc(std::string("Spectrum version: ") + SPECTRUM_VERSION + "\nUsage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");

	desc.add_options()

		("help,h", "help")

		("no-daemonize,n", "Do not run spectrum as daemon")

		("no-debug,d", "Create coredumps on crash")

		("jid,j", boost::program_options::value<std::string>(&jid)->default_value(""), "Specify JID of transport manually")

		("config", boost::program_options::value<std::string>(&config_file)->default_value(""), "Config file")

		("version,v", "Shows Spectrum version")

		;

	try

	{

		boost::program_options::positional_options_description p;

		p.add("config", -1);

		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).

          options(desc).positional(p).allow_unregistered().run(), vm);

		boost::program_options::notify(vm);

		if (vm.count("version")) {

			std::cout << SPECTRUM_VERSION << "\n";

			return 0;

		}

		if(vm.count("help"))

		{

			std::cout << desc << "\n";

			return 1;

		}

		if(vm.count("config") == 0) {

			std::cout << desc << "\n";

			return 1;

		}

		if(vm.count("no-daemonize")) {

			no_daemon = true;

		}

#include "managerconfig.h"

#include "transport/config.h"

#include "transport/protocol.pb.h"

#include "Swiften/Swiften.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include <boost/foreach.hpp>

#include <iostream>

#include <fstream>

#include <iterator>

#include <algorithm>

#include <boost/filesystem.hpp>

#include "signal.h"

#include "sys/wait.h"

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

using namespace Transport;

using namespace boost::filesystem;

using namespace boost;

std::string _data;

static std::string searchForBinary(const std::string &binary) {

	std::vector<std::string> path_list;

	char * env_path = getenv("PATH");

	if (env_path != NULL) {

		std::string buffer = "";

		for (int s = 0; s < strlen(env_path); s++) {

			if (env_path[s] == ':') {

				path_list.insert(path_list.end(), std::string(buffer));

				buffer = "";

			}

			else {

				buffer += env_path[s];

			}

		}

		if (buffer != "") {

			path_list.insert(path_list.end(), std::string(buffer));

			buffer = "";

		}

		for (std::vector<std::string>::iterator dit = path_list.begin(); dit < path_list.end(); dit++) {

			std::string bpath = *dit;

			bpath += "/";

			bpath += binary;

			path p(bpath);

			if (exists(p) && !is_directory(p)) {

				return bpath;

			}

		}

	}

	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <COMMAND>\n"

													 "       spectrum [OPTIONS] <instance_JID> <other>\nCommands:\n"

													 " start - start all local Spectrum2 instances\n"

													 " stop  - stop all local Spectrum2 instances\n"

													 " status - status of local Spectrum2 instances\n"

													 " <other> - send command to local Spectrum2 instance and print output\n"

													 "Allowed options");

	desc.add_options()

		("help,h", "Show help output")

		("config,c", boost::program_options::value<std::string>(&config_file)->default_value("/etc/spectrum2/spectrum_manager.cfg"), "Spectrum manager config file")

		("command", boost::program_options::value<std::vector<std::string> >(&command), "Command")

		;

	try

	{

		boost::program_options::positional_options_description p;

		p.add("command", -1);

		boost::program_options::store(boost::program_options::command_line_parser(argc, argv).

          options(desc).positional(p).run(), vm);

		boost::program_options::notify(vm);

		if(vm.count("help"))

		{

			std::cout << desc << "\n";

			return 1;

		}

	}

	catch (std::runtime_error& e)

	{

		std::cout << desc << "\n";

		return 2;

	}

	catch (...)

	{

		std::cout << desc << "\n";

		return 3;

	}

	if (!config.load(config_file)) {

		std::cerr << "Can't load configuration file.\n";

		return 4;

	}

	if (command.empty()) {

		std::cout << desc << "\n";

		return 1;

	}

	if (command[0] == "start") {

		start_instances(&config);

	}

	else if (command[0] == "stop") {

		stop_instances(&config);

	}

	else if (command[0] == "status") {

		return show_status(&config);

	}

	else if (command[0] == "list") {

		show_list(&config);

	}

	else {

		if (command.size() < 2) {

			std::cout << desc << "\n";

			return 11;

		}

		Swift::SimpleEventLoop eventLoop;

		Swift::BoostNetworkFactories networkFactories(&eventLoop);

		std::string jid = command[0];

		command.erase(command.begin());

		std::string cmd = boost::algorithm::join(command, " ");

		if (cmd == "start") {

			start_instances(&config, jid);

			return 0;

		}

		else if (cmd == "stop") {

			stop_instances(&config, jid);

			return 0;

		}

		ask_local_server(&config, networkFactories, jid, cmd);

// 		std::string message = command;

// 		m = &message;

// 		ask_local_server(&config, networkFactories, message);

		eventLoop.run();

	}

}