rc_server.cpp.svn-base

sigmadesign smp8623 gui source code ,bingo

	map<string, linked_ptr<room_status_t> >::iterator i = ctxt.rooms.find(msg->ip);
	if (i == ctxt.rooms.end())
		return;

	pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
	std::map<std::string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map_send.find(card);

	if (some != ctxt.rooms[msg->ip]->key_map_send.end())
		ctxt.rooms[msg->ip]->key_map_send.erase(some);

	pthread_cond_broadcast(&ctxt.rooms[msg->ip]->queue_not_empty);
	pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);
}

void ok_del_card(rc_msg_t* msg, string& card)
{
	map<string, linked_ptr<room_status_t> >::iterator i = ctxt.rooms.find(msg->ip);
	if (i == ctxt.rooms.end())
		return;

	pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
	std::map<std::string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map_send.find(card);

	if (some != ctxt.rooms[msg->ip]->key_map_send.end())
		ctxt.rooms[msg->ip]->key_map_send.erase(some);

	pthread_cond_broadcast(&ctxt.rooms[msg->ip]->queue_not_empty);
	pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);
}

void fail_del_card(rc_msg_t* msg, string &param, uint16 error)
{
	map<string, linked_ptr<room_status_t> >::iterator i = ctxt.rooms.find(msg->ip);
	if (i == ctxt.rooms.end())
		return;

	std::string message;
	switch (error)
	{
	case 1:
		message = "картата не съществува";
		break;
	case 2:
		message = "грешка в паметта на контролера";
		break;
	case 3:
		message = "невалидна чексума";
		break;
	}

	pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
	std::map<std::string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map_send.begin();

	for (; some != ctxt.rooms[msg->ip]->key_map_send.end(); some++)
	{
		char* n;
		if ((n = strcasestr(some->first.c_str(), param.c_str())) != NULL)
		{
			ctxt.rooms[msg->ip]->key_map_send.erase(some);
			break;
		}
	}
	pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);

	std::ostringstream str_err_msg;

	str_err_msg << "Неуспешно изтриване на карта 0x" << param << " за стая " << ctxt.rooms[msg->ip]->room << ". Причина: " << message;

	write_event(4, str_err_msg);
}

void stop_radio(std::string &ip)
{
	int radio = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
//	if (ctxt.pmssock == -1)
//	{
//		logger(ERROR, "Can't create socket for radio server: %s\n", strerror(errno));
//
//		return;
//	}

	struct sockaddr_in isa;

	isa.sin_family = AF_INET;
	isa.sin_port = htons(ctxt.conf->radio_port);
	inet_aton(ctxt.conf->radio_host.c_str(), &isa.sin_addr);

	try
	{
//		do
		{
//			pollfd pfd;
//			pfd.fd = radio;
//			pfd.events = POLLOUT;
//
//			int ready = poll(&pfd, 1, 2000);

		//	if (ready != -1)
			{
				//		printf("%.2x\n", pfd.revents);
			//	if (pfd.revents == POLLHUP)
				{
					int ret = connect(radio, (sockaddr*) &isa, sizeof(isa));
					if (ret == -1)
					{
						logger(ERROR, "Can not connet to IP address %s: %s\n", ctxt.conf->radio_host.c_str(), strerror(errno));
						//break;
					}
					else
					{
						std::ostringstream buffer;
						buffer << "RADC|RA" << ctxt.rooms[ip]->room << "|ON0|\r\n";

						send(radio, buffer.str().c_str(), buffer.str().length(), 0);
						//break;
					}

				}

			}
//			else
//			{
//				throw errno;
//			}

		} //while (ctxt.shutdown != 1);
	} catch (int& n)
	{
		logger(FATAL, "Error in radio server on IP address %s: %s\n", ctxt.conf->radio_host.c_str(), strerror(n));
	}

	shutdown(radio, SHUT_RDWR);
	close(radio);
}

void power_on(rc_msg_t* msg, std::string& param)
{
	map<string, linked_ptr<room_status_t> >::iterator i = ctxt.rooms.find(msg->ip);
	if (i == ctxt.rooms.end())
		return;

	BEGIN_DB()std::ostringstream get_key;

		get_key << "SELECT HEX(PowerKeyID) FROM RoomStatus WHERE RoomID=" << ctxt.rooms[msg->ip]->room;

		mysqlpp::StoreQueryResult res = qr.store(get_key.str().c_str());

		std::string cur_id = "0";

		if(res.num_rows()> 0)
		{
			cur_id = res[0][0].c_str();
		}

		if(cur_id.compare(param))
		{
			std::ostringstream update_room_status;
			std::ostringstream update_door_lock;

			update_room_status << "UPDATE RoomStatus SET PowerKeyID=0x"<<param<<" WHERE RoomID="<<ctxt.rooms[msg->ip]->room;
			qr.execute(update_room_status.str().c_str());

			int event;

			if(!param.compare("0000000000000000"))
			{
				event = 5;
				stop_radio(msg->ip);
			}
			else
			{
				event = 4;
			}

			update_door_lock << "INSERT INTO DoorLockLog (EventDate, RoomID, EventID, KeyID) VALUES('"<< get_date_time <<"', " << ctxt.rooms[msg->ip]->room << ", "<<event<<", 0x"<<param<<")";

			qr.execute(update_door_lock.str().c_str());
		}
		END_DB()
	}

void open_door(rc_msg* msg, std::string& param)
{
	map<string, linked_ptr<room_status_t> >::iterator i = ctxt.rooms.find(msg->ip);
	if (i == ctxt.rooms.end())
		return;

	BEGIN_DB()
		std::ostringstream update_door_lock;

		update_door_lock << "INSERT INTO DoorLockLog (EventDate, RoomID, EventID, KeyID) VALUES('"<< get_date_time <<"', " << ctxt.rooms[msg->ip]->room << ", 3, 0x"<<param<<")";

		qr.execute(update_door_lock.str().c_str());
	END_DB()

}

void is_alive(rc_msg_t* msg, string& aa)
{
	map<string, linked_ptr<room_status_t> >::iterator i = ctxt.rooms.find(msg->ip);
	if (i == ctxt.rooms.end())
		return;

	BEGIN_DB()
		pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
		ctxt.rooms[msg->ip]->status = 1;
		ctxt.rooms[msg->ip]->lastping = time(NULL);
		if(ctxt.rooms[msg->ip]->oldstatus != 1)
		{
			ctxt.rooms[msg->ip]->oldstatus = 1;
			ctxt.rooms[msg->ip]->lastchange = time(NULL);

			change_room_status(conn, msg->ip, ctxt.rooms[msg->ip]->room);
		}
		pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);

		std::ostringstream get_cards;

		get_cards << "SELECT HEX(KeyID), IsUnlock, IsPower FROM KeycardRoom WHERE RoomID="<< ctxt.rooms[msg->ip]->room <<" ORDER BY KeyID asc";

		mysqlpp::StoreQueryResult res = qr.store(get_cards.str().c_str());

		for(size_t i = 0; i < res.num_rows(); i++)
		{
			std::ostringstream key;

			key << res[i][0].c_str() << str_to_int(res[i][1].c_str()) << str_to_int(res[i][2].c_str());

			string _t = key.str();

			pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
			ctxt.rooms[msg->ip]->key_map[_t] = false;
			pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);
		}

		uint16 crc16 = 0;
		pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
		std::map<string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map.begin();
		for(; some != ctxt.rooms[msg->ip]->key_map.end(); some++)
		{
			const char* c = some->first.c_str();
			for(int i = 0; i < 18; i++)
			{
				crc16 = crc16 ^ static_cast<unsigned short>(c[i] << 8);

				for(int bit = 0; bit < 8; bit++)
				{
					if(crc16 & 0x8000)
					{
						crc16 = (crc16 << 1) ^ 0x1021;
					}
					else
					{
						crc16 = (crc16 << 1);
					}
				}
			}
		}

		bool status = ctxt.rooms[msg->ip]->prog;
		pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);

		uint16 crc_command = strtol(aa.c_str(), (char**)NULL, 16);

		if(crc_command != crc16 && status == false)
		{
			logger(ERROR, "Different crc %X for rc %s. Must be %X", crc_command, msg->ip.c_str(), crc16);
			if(ctxt.rooms[msg->ip]->key_map_send.size() == 0)
			{
				pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
				ctxt.rooms[msg->ip]->key_map_send[std::string("0000000000000000")] = true;
				std::map<string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map.begin();
				for(; some != ctxt.rooms[msg->ip]->key_map.end(); some++)
				{
					ctxt.rooms[msg->ip]->key_map_send[some->first] = some->second;
				}
				pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);
			}

			int nTimeOuts = 0;

			//while(ctxt.rooms[msg->ip]->key_map_send.size() != 0)
			pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
			std::map<string, bool>::iterator it = ctxt.rooms[msg->ip]->key_map_send.begin();
			std::map<string, bool> temp;
			for(;it != ctxt.rooms[msg->ip]->key_map_send.end(); it++)
			{
				temp[it->first] = it->second;
			}

			ctxt.rooms[msg->ip]->prog = true;
			ctxt.rooms[msg->ip]->tryprog ++;
			pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);
			std::map<string, bool>::iterator some = temp.begin();
			for(;some != temp.end(); some++)
			{
				std::ostringstream udp_send;

				udp_send.fill('0');
				if(some->second == false)
				udp_send << "PROG:" << some->first << "*";
				else
				{
					std::string _t = some->first;
					//			_t[_t.length() - 1] = '\0';
					//			_t[_t.length() - 1] = '\0';
					udp_send <<"BLNK:" << _t << "*";
				}

				//CRC(udp_send);

				send_to_rc(msg->ip, udp_send);

				timeval now;
				gettimeofday(&now, NULL);
				sleep(1);
				//	 ctxt.rooms[msg->ip]->key_map.erase(some);
				timespec timeout;
				timeout.tv_sec = now.tv_sec + 2;
				timeout.tv_nsec = now.tv_usec * 1000;
				int retcode = 0;

				//retcode = pthread_cond_timedwait(&ctxt.rooms[msg->ip]->queue_not_empty, &ctxt.rooms[msg->ip]->lock, &timeout);

				if(retcode == ETIMEDOUT)
				{
					std::cout << "timeout\n";

					nTimeOuts++;

					if(nTimeOuts> 14)
					{
						pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);
						break;
					}
				}
			}
			//	pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);

			//		if(nTimeOuts > 14)

			{
				pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
				while(ctxt.rooms[msg->ip]->key_map.size() != 0)
				{
					std::map<string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map.begin();
					ctxt.rooms[msg->ip]->key_map.erase(some);
				}
				ctxt.rooms[msg->ip]->prog = false;
				pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);
			}

			pthread_mutex_lock(&ctxt.rooms[msg->ip]->lock);
			if(ctxt.rooms[msg->ip]->tryprog> 9)
			{
				logger(ERROR, "Programming timeout for rc %s room %d\n", msg->ip.c_str(), ctxt.rooms[msg->ip]->room);
				ctxt.rooms[msg->ip]->tryprog = 0;
				while(ctxt.rooms[msg->ip]->key_map.size() != 0)
				{
					std::map<string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map.begin();
					ctxt.rooms[msg->ip]->key_map.erase(some);
				}
				while(ctxt.rooms[msg->ip]->key_map_send.size() != 0)
				{
					std::map<string, bool>::iterator some = ctxt.rooms[msg->ip]->key_map_send.begin();
					ctxt.rooms[msg->ip]->key_map_send.erase(some);
				}
			}
			pthread_mutex_unlock(&ctxt.rooms[msg->ip]->lock);