Hu Chunming / sip_server

Commit c887a0f0dcc104c68e4004c400c7c95c07742be8

Authored by Hu Chunming 2024-04-26 14:44:58 +0800

0 parents

提交初成版代码

.vscode/launch.json 0 → 100644

		1	+++ a/.vscode/launch.json
		1	+{
		2	+ // 使用 IntelliSense 了解相关属性。
		3	+ // 悬停以查看现有属性的描述。
		4	+ // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
		5	+ "version": "0.2.0",
		6	+ "configurations": [
		7	+ {
		8	+ "name": "gb28181",
		9	+ "type": "cppdbg",
		10	+ "request": "launch",
		11	+ "program": "${workspaceFolder}/bin/sip_server",
		12	+ "args": ["34020000001310000001"],
		13	+ "stopAtEntry": false,
		14	+ "cwd": "${workspaceFolder}/bin",
		15	+ "environment": [],
		16	+ "externalConsole": false,
		17	+ "MIMode": "gdb",
		18	+ "setupCommands": [
		19	+ {
		20	+ "description": "Enable pretty-printing for gdb",
		21	+ "text": "-enable-pretty-printing",
		22	+ "ignoreFailures": true
		23	+ }
		24	+ ]
		25	+ }
		26	+ ]
		27	+}
0	\ No newline at end of file	28	\ No newline at end of file

sip/ConfigParser.hpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/ConfigParser.hpp
		1	+#ifndef __CONFIG_PARSER_H__
		2	+#define __CONFIG_PARSER_H__
		3	+
		4	+#include <fstream>
		5	+#include "./Message/CatalogParser.h"
		6	+#include "sip_header.h"
		7	+#include "./Utils/logger.hpp"
		8	+
		9	+
		10	+class ConfigParser
		11	+{
		12	+public:
		13	+ static ConfigParser* getInstance(){
		14	+ static ConfigParser* singleton = nullptr;
		15	+ if (singleton == nullptr){
		16	+ singleton = new ConfigParser();
		17	+ }
		18	+ return singleton;
		19	+ }
		20	+
		21	+public:
		22	+ ConfigParser(/* args */);
		23	+ ~ConfigParser();
		24	+
		25	+ bool init();
		26	+
		27	+ ServerInfo getServerCfg();
		28	+
		29	+private:
		30	+ ServerInfo mInfo;
		31	+
		32	+};
		33	+
		34	+ConfigParser::ConfigParser(/* args */)
		35	+{
		36	+}
		37	+
		38	+ConfigParser::~ConfigParser()
		39	+{
		40	+}
		41	+
		42	+bool ConfigParser::init() {
		43	+ std::ifstream cfgFile("./sip_server_cfg.xml");
		44	+ if(cfgFile.is_open()) {
		45	+ string strConfig;
		46	+ string str;
		47	+ while(cfgFile >> str)
		48	+ {
		49	+ strConfig += str;
		50	+ }
		51	+ CCatalogParser catPaser;
		52	+ mInfo = catPaser.DecodeServerConfig(strConfig.c_str());
		53	+ } else {
		54	+ LOG_ERROR("read config file failed!");
		55	+ return false;
		56	+ }
		57	+ cfgFile.close();
		58	+
		59	+ return true;
		60	+}
		61	+
		62	+ServerInfo ConfigParser::getServerCfg() {
		63	+ return mInfo;
		64	+}
		65	+
		66	+#endif
0	\ No newline at end of file	67	\ No newline at end of file

sip/Message/CatalogParser.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/Message/CatalogParser.cpp
		1	+#include "CatalogParser.h"
		2	+#include <sstream>
		3	+#include <list>
		4	+
		5	+#include "../Utils/logger.hpp"
		6	+
		7	+static const char* g_event_desc[] =
		8	+{
		9	+ "ON",
		10	+ "OFF",
		11	+ "VLOST",
		12	+ "DEFECT",
		13	+ "ADD",
		14	+ "DEL",
		15	+ "UPDATE"
		16	+};
		17	+
		18	+
		19	+bool CCatalogParser::Encode( std::string &message )
		20	+{
		21	+ std::ostringstream content;
		22	+ content<<"<?xml version=\"1.0\"?>\r\n";
		23	+ content<<"<Notify>\r\n";
		24	+ content<<"<CmdType>Catalog</CmdType>\r\n";
		25	+ content<<"<SN>"<< m_sn <<"</SN>\r\n";
		26	+ content<<"<DeviceID>"<< m_deviceid <<"</DeviceID>\r\n";
		27	+ content<<"<Status>OK</Status>\r\n";
		28	+ content<<"<SumNum>"<< m_sum <<"</SumNum>\r\n";
		29	+ content<<"<DeviceList Num=\"" << m_devices.size() << "\">\r\n";
		30	+
		31	+ for( auto it = m_devices.begin(); it != m_devices.end(); ++it )
		32	+ {
		33	+ // 校验目录项的必选参数
		34	+ const DeviceInfo &catalog = (*it);
		35	+ content<<"<Item>\r\n";
		36	+ content<<"<DeviceID>"<<catalog.id<<"</DeviceID>\r\n";
		37	+ content<<"<Event>"<< g_event_desc[catalog.event] <<"</Event>\r\n";
		38	+
		39	+ if( catalog.event == EVENT_ADD \|\| catalog.event == EVENT_UPDATE )
		40	+ {
		41	+ content<<"<Name>"<< catalog.name <<"</Name>\r\n";
		42	+ content<<"<Manufacturer>"<< catalog.manufacturer <<"</Manufacturer>\r\n";
		43	+ content<<"<Model>"<< catalog.model <<"</Model>\r\n";
		44	+ content<<"<Owner>"<< catalog.owner <<"</Owner>\r\n";
		45	+
		46	+ if( !catalog.civil.empty() )
		47	+ {
		48	+ content<<"<CivilCode>"<<catalog.civil<<"</CivilCode>\r\n";
		49	+ }
		50	+ else
		51	+ {
		52	+ content<<"<CivilCode>"<<catalog.parentid<<"</CivilCode>\r\n";
		53	+ }
		54	+
		55	+ if( !catalog.block.empty() )
		56	+ {
		57	+ content<<"<Block>"<< catalog.block <<"</Block>\r\n";
		58	+ }
		59	+
		60	+ content<<"<Address>"<< catalog.address <<"</Address>\r\n";
		61	+ content<<"<Parental>"<< catalog.parental <<"</Parental>\r\n";
		62	+ content<<"<ParentID>"<< catalog.parentid <<"</ParentID>\r\n";
		63	+
		64	+ if( !catalog.safetyway.empty() )
		65	+ {
		66	+ content<<"<SafetyWay>"<< catalog.safetyway <<"</SafetyWay>\r\n";
		67	+ }
		68	+
		69	+ content<<"<RegisterWay>"<< catalog.registerway <<"</RegisterWay>\r\n";
		70	+
		71	+ if( !catalog.certnum.empty() )
		72	+ {
		73	+ content<<"<CertNum>"<< catalog.certnum <<"</CertNum>\r\n";
		74	+ }
		75	+
		76	+ if( !catalog.certifiable.empty() )
		77	+ {
		78	+ content<<"<Certifiable>"<< catalog.certifiable <<"</Certifiable>\r\n";
		79	+ }
		80	+
		81	+ if( !catalog.errcode.empty() )
		82	+ {
		83	+ content<<"<ErrCode>"<< catalog.errcode <<"</ErrCode>\r\n";
		84	+ }
		85	+
		86	+ if( !catalog.endtime.empty() )
		87	+ {
		88	+ content<<"<EndTime>"<< catalog.endtime <<"</EndTime>\r\n";
		89	+ }
		90	+
		91	+ content<<"<Secrecy>"<< catalog.secrecy <<"</Secrecy>\r\n";
		92	+
		93	+ if( !catalog.ip.empty() )
		94	+ {
		95	+ content<<"<IPAddress>"<< catalog.ip <<"</IPAddress>\r\n";
		96	+ }
		97	+
		98	+ if( !catalog.port.empty() )
		99	+ {
		100	+ content<<"<Port>"<< catalog.port <<"</Port>\r\n";
		101	+ }
		102	+
		103	+ if( !catalog.password.empty() )
		104	+ {
		105	+ content<<"<Password>"<< catalog.password <<"</Password>\r\n";
		106	+ }
		107	+
		108	+ content<<"<Status>"<<catalog.status<<"</Status>\r\n";
		109	+
		110	+ if( !catalog.longitude.empty() )
		111	+ {
		112	+ content<<"<Longitude>"<<catalog.longitude<<"</Longitude>\r\n";
		113	+ }
		114	+
		115	+ if( !catalog.latitude.empty() )
		116	+ {
		117	+ content<<"<Latitude>"<<catalog.latitude<<"</Latitude>\r\n";
		118	+ }
		119	+
		120	+ content<<"<Info>\r\n";
		121	+ if( !catalog.ptz.empty() )
		122	+ {
		123	+ content<<"<PTZType>"<<catalog.ptz<<"</PTZType>\r\n";
		124	+ }
		125	+
		126	+ if( !catalog.position.empty() )
		127	+ {
		128	+ content<<"<PositionType>"<<catalog.position<<"</PositionType>\r\n";
		129	+ }
		130	+
		131	+ if( !catalog.room.empty() )
		132	+ {
		133	+ content<<"<RoomType>"<<catalog.room<<"</RoomType>\r\n";
		134	+ }
		135	+
		136	+ if( !catalog.use.empty() )
		137	+ {
		138	+ content<<"<UseType>"<<catalog.use<<"</UseType>\r\n";
		139	+ }
		140	+
		141	+ if( !catalog.supplylight.empty() )
		142	+ {
		143	+ content<<"<SupplyLightType>"<<catalog.supplylight<<"</SupplyLightType>\r\n";
		144	+ }
		145	+
		146	+ if( !catalog.direction.empty() )
		147	+ {
		148	+ content<<"<DirectionType>"<<catalog.direction<<"</DirectionType>\r\n";
		149	+ }
		150	+
		151	+ if( !catalog.resolution.empty() )
		152	+ {
		153	+ content<<"<Resolution>"<<catalog.resolution<<"</Resolution>\r\n";
		154	+ }
		155	+
		156	+ if( !catalog.businessgroup.empty() )
		157	+ {
		158	+ content<<"<BusinessGroupID>"<<catalog.businessgroup<<"</BusinessGroupID>\r\n";
		159	+ }
		160	+
		161	+ content<<"</Info>\r\n";
		162	+ }
		163	+
		164	+ content<<"</Item>\r\n";
		165	+ }
		166	+ content<<"</DeviceList>\r\n";
		167	+ content<<"</Notify>\r\n\r\n";
		168	+
		169	+ message = content.str();
		170	+ return true;
		171	+}
		172	+
		173	+std::vector< DeviceInfo > CCatalogParser::Decode( const std::vector< tinyxml2::XMLNode* > &nodes)
		174	+{
		175	+ std::vector< DeviceInfo > cat_list;
		176	+ // 必须参数校验
		177	+ tinyxml2::XMLNode *pSumNum = NULL;
		178	+ size_t size = nodes.size();
		179	+ for( size_t i = 0; i < size; ++i )
		180	+ {
		181	+ tinyxml2::XMLNode *pNode = nodes[i];
		182	+ if( pNode == NULL )
		183	+ {
		184	+ LOG_DEBUG( "参数错误" );
		185	+ continue;
		186	+ }
		187	+
		188	+ const char* type = pNode->Value();
		189	+ if( type == NULL )
		190	+ {
		191	+ LOG_DEBUG( "参数名字为空" );
		192	+ continue;
		193	+ }
		194	+
		195	+ if( CGBMessage::CompareNoCase( type, "SumNum" ) )
		196	+ {
		197	+ pSumNum = pNode;
		198	+ }
		199	+ }
		200	+
		201	+ // 必选参数必须填
		202	+ if( pSumNum == NULL )
		203	+ {
		204	+ LOG_ERROR( "参数SumNum没有被设置" );
		205	+ return cat_list;
		206	+ }
		207	+
		208	+ // 参数解析
		209	+ std::list< tinyxml2::XMLNode* > items;
		210	+ for( size_t i = 0; i < size; ++i )
		211	+ {
		212	+ tinyxml2::XMLNode *pNode = nodes[i];
		213	+ if( pNode == NULL )
		214	+ {
		215	+ LOG_DEBUG( "参数错误" );
		216	+ continue;
		217	+ }
		218	+
		219	+ const char* type = pNode->Value();
		220	+ if( type == NULL )
		221	+ {
		222	+ LOG_DEBUG( "参数名字为空" );
		223	+ continue;
		224	+ }
		225	+
		226	+ if( CGBMessage::CompareNoCase( type, "Status" ) )
		227	+ {
		228	+ tinyxml2::XMLNode *pChild = pNode->FirstChild();
		229	+ if( pChild == NULL )
		230	+ {
		231	+ LOG_DEBUG( "参数值没有设置" );
		232	+ continue;
		233	+ }
		234	+
		235	+ const char *value = pChild->Value();
		236	+ if( value == NULL )
		237	+ {
		238	+ LOG_DEBUG( "参数值为空" );
		239	+ continue;
		240	+ }
		241	+ else
		242	+ {
		243	+ m_status = value;
		244	+ }
		245	+ }
		246	+ else if( CGBMessage::CompareNoCase( type, "SumNum" ) )
		247	+ {
		248	+ tinyxml2::XMLNode *pChild = pNode->FirstChild();
		249	+ if( pChild == NULL )
		250	+ {
		251	+ LOG_DEBUG( "参数值没有设置" );
		252	+ continue;
		253	+ }
		254	+
		255	+ const char *value = pChild->Value();
		256	+ if( value == NULL )
		257	+ {
		258	+ LOG_DEBUG( "参数值为空" );
		259	+ continue;
		260	+ }
		261	+ else
		262	+ {
		263	+ m_sum = atoi( value );
		264	+ }
		265	+ }
		266	+ else if( CGBMessage::CompareNoCase( type, "DeviceList" ) )
		267	+ {
		268	+ for(tinyxml2::XMLNode *pItem = pNode->FirstChild(); pItem != NULL; pItem = pItem->NextSibling() )
		269	+ {
		270	+ const char *type = pItem->Value();
		271	+ if( type == NULL )
		272	+ {
		273	+ LOG_DEBUG( "参数名字为空" );
		274	+ continue;
		275	+ }
		276	+
		277	+ if( CGBMessage::CompareNoCase( type, "Item" ) )
		278	+ {
		279	+ items.push_back( pItem );
		280	+ }
		281	+ else
		282	+ {
		283	+ LOG_DEBUG( "国标未定义的参数:{}" , type );
		284	+ continue;
		285	+ }
		286	+ }
		287	+ }
		288	+ else
		289	+ {
		290	+ LOG_DEBUG( "国标未定义的参数:{}" , type );
		291	+ continue;
		292	+ }
		293	+ }
		294	+
		295	+ // 目录项
		296	+ std::list< tinyxml2::XMLNode* >::iterator it = items.begin();
		297	+ std::list< tinyxml2::XMLNode* >::iterator end = items.end();
		298	+ for( /it/; it != end; ++it )
		299	+ {
		300	+ DeviceInfo catalog;
		301	+ for(tinyxml2::XMLNode pItem = (it)->FirstChild(); pItem != NULL; pItem = pItem->NextSibling() )
		302	+ {
		303	+ const char *type = pItem->Value();
		304	+ if( type == NULL )
		305	+ {
		306	+ LOG_DEBUG( "参数名字为空" );
		307	+ continue;
		308	+ }
		309	+
		310	+ tinyxml2::XMLNode *pValue = pItem->FirstChild();
		311	+ if( pValue == NULL )
		312	+ {
		313	+ LOG_DEBUG( "参数值没有设置" );
		314	+ continue;
		315	+ }
		316	+
		317	+ const char *value = pValue->Value();
		318	+ if( value == NULL )
		319	+ {
		320	+ LOG_DEBUG( "参数值为空" );
		321	+ continue;
		322	+ }
		323	+
		324	+ if( CGBMessage::CompareNoCase( type, "DeviceID" ) )
		325	+ {
		326	+ catalog.id = value;
		327	+ }
		328	+ else if( CGBMessage::CompareNoCase( type, "Event" ) )
		329	+ {
		330	+ if( CGBMessage::CompareNoCase( value, "ON" ) )
		331	+ {
		332	+ catalog.event = EVENT_ON;
		333	+ }
		334	+ else if( CGBMessage::CompareNoCase( value, "OFF" ) )
		335	+ {
		336	+ catalog.event = EVENT_OFF;
		337	+ }
		338	+ else if( CGBMessage::CompareNoCase( value, "VLOST" ) )
		339	+ {
		340	+ catalog.event = EVENT_VLOST;
		341	+ }
		342	+ else if( CGBMessage::CompareNoCase( value, "DEFECT" ) )
		343	+ {
		344	+ catalog.event = EVENT_DEFECT;
		345	+ }
		346	+ else if( CGBMessage::CompareNoCase( value, "ADD" ) )
		347	+ {
		348	+ catalog.event = EVENT_ADD;
		349	+ }
		350	+ else if( CGBMessage::CompareNoCase( value, "DEL" ) )
		351	+ {
		352	+ catalog.event = EVENT_DEL;
		353	+ }
		354	+ else if( CGBMessage::CompareNoCase( value, "UPDATE" ) )
		355	+ {
		356	+ catalog.event = EVENT_UPDATE;
		357	+ }
		358	+ else
		359	+ {
		360	+ LOG_ERROR( "Event参数值\'{}\'无效", value );
		361	+ return cat_list;
		362	+ }
		363	+ }
		364	+ else if( CGBMessage::CompareNoCase( type, "Name" ) )
		365	+ {
		366	+ catalog.name = value;
		367	+ }
		368	+ else if( CGBMessage::CompareNoCase( type, "Manufacturer" ) )
		369	+ {
		370	+ catalog.manufacturer = value;
		371	+ }
		372	+ else if( CGBMessage::CompareNoCase( type, "Model" ) )
		373	+ {
		374	+ catalog.model = value;
		375	+ }
		376	+ else if( CGBMessage::CompareNoCase( type, "Owner" ) )
		377	+ {
		378	+ catalog.owner = value;
		379	+ }
		380	+ else if( CGBMessage::CompareNoCase( type, "CivilCode" ) )
		381	+ {
		382	+ catalog.civil = value;
		383	+ }
		384	+ else if( CGBMessage::CompareNoCase( type, "Block" ) )
		385	+ {
		386	+ catalog.block = value;
		387	+ }
		388	+ else if( CGBMessage::CompareNoCase( type, "Address" ) )
		389	+ {
		390	+ catalog.address = value;
		391	+ }
		392	+ else if( CGBMessage::CompareNoCase( type, "Parental" ) )
		393	+ {
		394	+ catalog.parental = value;
		395	+ }
		396	+ else if( CGBMessage::CompareNoCase( type, "ParentID" ) )
		397	+ {
		398	+ catalog.parentid = value;
		399	+ }
		400	+ else if( CGBMessage::CompareNoCase( type, "SafetyWay" ) )
		401	+ {
		402	+ catalog.safetyway = value;
		403	+ }
		404	+ else if( CGBMessage::CompareNoCase( type, "RegisterWay" ) )
		405	+ {
		406	+ catalog.registerway = value;
		407	+ }
		408	+ else if( CGBMessage::CompareNoCase( type, "CertNum" ) )
		409	+ {
		410	+ catalog.certnum = value;
		411	+ }
		412	+ else if( CGBMessage::CompareNoCase( type, "Certifiable" ) )
		413	+ {
		414	+ catalog.certifiable = value;
		415	+ }
		416	+ else if( CGBMessage::CompareNoCase( type, "ErrCode" ) )
		417	+ {
		418	+ catalog.errcode = value;
		419	+ }
		420	+ else if( CGBMessage::CompareNoCase( type, "EndTime" ) )
		421	+ {
		422	+ catalog.endtime = value;
		423	+ }
		424	+ else if( CGBMessage::CompareNoCase( type, "Secrecy" ) )
		425	+ {
		426	+ catalog.secrecy = value;
		427	+ }
		428	+ else if( CGBMessage::CompareNoCase( type, "IPAddress" ) )
		429	+ {
		430	+ catalog.ip = value;
		431	+ }
		432	+ else if( CGBMessage::CompareNoCase( type, "Port" ) )
		433	+ {
		434	+ catalog.port = value;
		435	+ }
		436	+ else if( CGBMessage::CompareNoCase( type, "Password" ) )
		437	+ {
		438	+ catalog.password = value;
		439	+ }
		440	+ else if( CGBMessage::CompareNoCase( type, "Status" ) )
		441	+ {
		442	+ catalog.status = value;
		443	+ }
		444	+ else if( CGBMessage::CompareNoCase( type, "Longitude" ) )
		445	+ {
		446	+ catalog.longitude = value;
		447	+ }
		448	+ else if( CGBMessage::CompareNoCase( type, "Latitude" ) )
		449	+ {
		450	+ catalog.latitude = value;
		451	+ }
		452	+ else if( CGBMessage::CompareNoCase( type, "PTZType" ) )
		453	+ {
		454	+ catalog.ptz = value;
		455	+ }
		456	+ else if( CGBMessage::CompareNoCase( type, "PositionType" ) )
		457	+ {
		458	+ catalog.position = value;
		459	+ }
		460	+ else if( CGBMessage::CompareNoCase( type, "RoomType" ) )
		461	+ {
		462	+ catalog.room = value;
		463	+ }
		464	+ else if( CGBMessage::CompareNoCase( type, "UseType" ) )
		465	+ {
		466	+ catalog.use = value;
		467	+ }
		468	+ else if( CGBMessage::CompareNoCase( type, "SupplyLightType" ) )
		469	+ {
		470	+ catalog.supplylight = value;
		471	+ }
		472	+ else if( CGBMessage::CompareNoCase( type, "DirectionType" ) )
		473	+ {
		474	+ catalog.direction = value;
		475	+ }
		476	+ else if( CGBMessage::CompareNoCase( type, "Resolution" ) )
		477	+ {
		478	+ catalog.resolution = value;
		479	+ }
		480	+ else if( CGBMessage::CompareNoCase( type, "BusinessGroupID" ) )
		481	+ {
		482	+ catalog.businessgroup = value;
		483	+ }
		484	+ else if( CGBMessage::CompareNoCase( type, "Info" ) )
		485	+ {
		486	+ for(tinyxml2::XMLNode *pInfo = pItem->FirstChild(); pInfo != NULL; pInfo = pInfo->NextSibling() )
		487	+ {
		488	+ pValue = pInfo->FirstChild();
		489	+ if( pValue == NULL )
		490	+ {
		491	+ LOG_DEBUG( "参数值没有设置" );
		492	+ continue;
		493	+ }
		494	+
		495	+ const char *type = pInfo->Value();
		496	+ if( type == NULL )
		497	+ {
		498	+ LOG_DEBUG( "参数名字为空" );
		499	+ continue;
		500	+ }
		501	+
		502	+ const char *value = pValue->Value();
		503	+ if( value == NULL )
		504	+ {
		505	+ LOG_DEBUG( "参数值为空" );
		506	+ continue;
		507	+ }
		508	+
		509	+ if( CGBMessage::CompareNoCase( type, "PTZType" ) )
		510	+ {
		511	+ catalog.ptz = value;
		512	+ }
		513	+ else if( CGBMessage::CompareNoCase( type, "PositionType" ) )
		514	+ {
		515	+ catalog.position = value;
		516	+ }
		517	+ else if( CGBMessage::CompareNoCase( type, "RoomType" ) )
		518	+ {
		519	+ catalog.room = value;
		520	+ }
		521	+ else if( CGBMessage::CompareNoCase( type, "UseType" ) )
		522	+ {
		523	+ catalog.use = value;
		524	+ }
		525	+ else if( CGBMessage::CompareNoCase( type, "SupplyLightType" ) )
		526	+ {
		527	+ catalog.supplylight = value;
		528	+ }
		529	+ else if( CGBMessage::CompareNoCase( type, "DirectionType" ) )
		530	+ {
		531	+ catalog.direction = value;
		532	+ }
		533	+ else if( CGBMessage::CompareNoCase( type, "Resolution" ) )
		534	+ {
		535	+ catalog.resolution = value;
		536	+ }
		537	+ else if( CGBMessage::CompareNoCase( type, "BusinessGroupID" ) )
		538	+ {
		539	+ catalog.businessgroup = value;
		540	+ }
		541	+ else
		542	+ {
		543	+ LOG_DEBUG( "国标未定义的参数:{}" , type );
		544	+ }
		545	+ }
		546	+ }
		547	+ else
		548	+ {
		549	+ LOG_DEBUG( "国标未定义的参数:{}" , type );
		550	+ }
		551	+ }
		552	+
		553	+ // add to devices
		554	+ m_devices.push_back( catalog );
		555	+ }
		556	+
		557	+ return m_devices;
		558	+}
		559	+
		560	+std::vector< DeviceInfo > CCatalogParser::DecodeCatlog(const char* body)
		561	+{
		562	+ std::vector< DeviceInfo > cat_list;
		563	+ if (body == NULL)
		564	+ {
		565	+ return cat_list;
		566	+ }
		567	+
		568	+ tinyxml2::XMLDocument doc;
		569	+ doc.Parse(body);
		570	+ tinyxml2::XMLElement* pRoot = doc.RootElement();
		571	+ if (pRoot == NULL)
		572	+ {
		573	+ return cat_list;
		574	+ }
		575	+
		576	+ tinyxml2::XMLNode* pCmd = 0;
		577	+ tinyxml2::XMLNode* pSN = 0;
		578	+ tinyxml2::XMLNode* pDeviceID = 0;
		579	+ std::vector< tinyxml2::XMLNode* > nodes;
		580	+ for (tinyxml2::XMLNode* pNode = pRoot->FirstChild(); pNode != 0; pNode = pNode->NextSibling())
		581	+ {
		582	+ std::string value = pNode->Value();
		583	+ if (value == "CmdType")
		584	+ {
		585	+ pCmd = pNode->FirstChild();
		586	+ }
		587	+ else if (value == "SN")
		588	+ {
		589	+ pSN = pNode->FirstChild();
		590	+ }
		591	+ else if (value == "DeviceID")
		592	+ {
		593	+ pDeviceID = pNode->FirstChild();
		594	+ }
		595	+ else
		596	+ {
		597	+ nodes.push_back(pNode);
		598	+ }
		599	+ }
		600	+
		601	+ if (pCmd == NULL \|\| pSN == NULL \|\| pDeviceID == NULL)
		602	+ {
		603	+ return cat_list;
		604	+ }
		605	+
		606	+ std::string sn = pSN->Value();
		607	+ if (sn.empty()) {
		608	+ return cat_list;
		609	+ }
		610	+
		611	+ std::string deviceid = pDeviceID->Value();
		612	+ if (deviceid.empty()) {
		613	+ return cat_list;
		614	+ }
		615	+
		616	+ std::string msgType = pRoot->Value();
		617	+ std::string cmdType = pCmd->Value();
		618	+ if (msgType == "Response" && cmdType == "Catalog")
		619	+ {
		620	+ cat_list = Decode(nodes);
		621	+ if (cat_list.empty())
		622	+ {
		623	+ LOG_WARN("消息体未解析出设备!");
		624	+ } else {
		625	+ // 设置
		626	+ for (size_t i = 0; i < cat_list.size(); i++) {
		627	+ cat_list[i].parentid = deviceid;
		628	+ }
		629	+ }
		630	+ }
		631	+
		632	+ return cat_list;
		633	+}
		634	+
		635	+string CCatalogParser::getItemValue(tinyxml2::XMLNode *pItem) {
		636	+
		637	+ tinyxml2::XMLNode *pValue = pItem->FirstChild();
		638	+ if( pValue == NULL ) {
		639	+ LOG_DEBUG( "参数值没有设置" );
		640	+ return "";
		641	+ }
		642	+
		643	+ const char *value = pValue->Value();
		644	+ if( value == NULL ) {
		645	+ LOG_DEBUG( "参数值为空" );
		646	+ return "";
		647	+ }
		648	+
		649	+ return value;
		650	+}
		651	+
		652	+ServerInfo CCatalogParser::DecodeServerConfig(const char* body)
		653	+{
		654	+ ServerInfo info;
		655	+ if (body == NULL) {
		656	+ return info;
		657	+ }
		658	+
		659	+ tinyxml2::XMLDocument doc;
		660	+ doc.Parse(body);
		661	+ tinyxml2::XMLElement* pRoot = doc.RootElement();
		662	+ if (pRoot == NULL) {
		663	+ return info;
		664	+ }
		665	+
		666	+ for (tinyxml2::XMLNode* pNode = pRoot->FirstChild(); pNode != 0; pNode = pNode->NextSibling())
		667	+ {
		668	+ std::string type = pNode->Value();
		669	+ if (CGBMessage::CompareNoCase( type, "Ua" ))
		670	+ {
		671	+ info.setUa(getItemValue(pNode));
		672	+ }
		673	+ else if (CGBMessage::CompareNoCase( type, "Nonce" ))
		674	+ {
		675	+ info.setNonce(getItemValue(pNode));
		676	+ }
		677	+ else if (CGBMessage::CompareNoCase( type, "Ip" ))
		678	+ {
		679	+ info.setIp(getItemValue(pNode));
		680	+ }
		681	+ else if (CGBMessage::CompareNoCase( type, "Port" ))
		682	+ {
		683	+ string str = getItemValue(pNode);
		684	+ int i = atoi(str.c_str());
		685	+ info.setPort(i);
		686	+ }
		687	+ else if (CGBMessage::CompareNoCase( type, "SipId" ))
		688	+ {
		689	+ info.setSipId(getItemValue(pNode));
		690	+ }
		691	+ else if (CGBMessage::CompareNoCase( type, "SipRealm" )) {
		692	+ info.setSipRealm(getItemValue(pNode));
		693	+ }
		694	+ else if (CGBMessage::CompareNoCase( type, "Password" )) {
		695	+ info.setSipPass(getItemValue(pNode));
		696	+ }
		697	+ else if (CGBMessage::CompareNoCase( type, "Timeout" )) {
		698	+ string str = getItemValue(pNode);
		699	+ int i = atoi(str.c_str());
		700	+ info.setTimeout(i);
		701	+ } else if (CGBMessage::CompareNoCase( type, "Expiry" )) {
		702	+ string str = getItemValue(pNode);
		703	+ int i = atoi(str.c_str());
		704	+ info.setExpiry(i);
		705	+ } else if (CGBMessage::CompareNoCase( type, "MinRtpPort" )) {
		706	+ string str = getItemValue(pNode);
		707	+ int i = atoi(str.c_str());
		708	+ info.setMinRtpPort(i);
		709	+ } else if (CGBMessage::CompareNoCase( type, "MaxRtpPort" )) {
		710	+ string str = getItemValue(pNode);
		711	+ int i = atoi(str.c_str());
		712	+ info.setMaxRtpPort(i);
		713	+ } else if (CGBMessage::CompareNoCase( type, "WsPort" )) {
		714	+ string str = getItemValue(pNode);
		715	+ int i = atoi(str.c_str());
		716	+ info.setWsPort(i);
		717	+ }
		718	+ }
		719	+
		720	+ return info;
		721	+}
0	\ No newline at end of file	722	\ No newline at end of file

sip/Message/CatalogParser.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/Message/CatalogParser.h
		1	+#ifndef MSG_NOTIFY_MSG_HPP_
		2	+#define MSG_NOTIFY_MSG_HPP_
		3	+
		4	+#include "GBMessage.h"
		5	+#include <vector>
		6	+
		7	+#include "../sip_header.h"
		8	+
		9	+class CCatalogParser : public CGBMessage
		10	+{
		11	+public:
		12	+ CCatalogParser()
		13	+ {
		14	+ }
		15	+
		16	+public:
		17	+ bool Encode( std::string &message );
		18	+
		19	+ std::vector<DeviceInfo> DecodeCatlog(const char* body);
		20	+
		21	+ ServerInfo DecodeServerConfig(const char* body);
		22	+
		23	+ static std::string GetStrName(EEventType eType)
		24	+ {
		25	+ switch (eType)
		26	+ {
		27	+ case EVENT_ON:
		28	+ return "ON";
		29	+ case EVENT_OFF:
		30	+ return "OFF";
		31	+ case EVENT_VLOST:
		32	+ return "VLOST";
		33	+ case EVENT_DEFECT:
		34	+ return "DEFECT";
		35	+ case EVENT_ADD:
		36	+ return "ADD";
		37	+ case EVENT_DEL:
		38	+ return "DEL";
		39	+ case EVENT_UPDATE:
		40	+ return "UPDATE";
		41	+ default: //EVENT_UNKNOW
		42	+ return "UNKNOW";
		43	+ }
		44	+
		45	+ return "UNKNOW";
		46	+ }
		47	+
		48	+ EEventType GetEnumName(const std::string &sType)
		49	+ {
		50	+ if (sType == "ON")
		51	+ return EVENT_ON;
		52	+ if (sType == "OFF")
		53	+ return EVENT_OFF;
		54	+ if (sType == "VLOSE")
		55	+ return EVENT_VLOST;
		56	+ if (sType == "DEFECT")
		57	+ return EVENT_DEFECT;
		58	+ if (sType == "ADD")
		59	+ return EVENT_ADD;
		60	+ if (sType == "DEL")
		61	+ return EVENT_DEL;
		62	+ if (sType == "UPDATE")
		63	+ return EVENT_UPDATE;
		64	+
		65	+ return EVENT_UNKNOW;
		66	+
		67	+ }
		68	+
		69	+
		70	+public:
		71	+
		72	+ inline const std::string& GetSN() const
		73	+ {
		74	+ return m_sn;
		75	+ }
		76	+
		77	+ inline const std::string& GetDeviceID() const
		78	+ {
		79	+ return m_deviceid;
		80	+ }
		81	+
		82	+ inline void SetDeviceID( const std::string &deviceid )
		83	+ {
		84	+ m_deviceid = deviceid;
		85	+ }
		86	+
		87	+ inline void SetSN( const std::string &sn )
		88	+ {
		89	+ m_sn = sn;
		90	+ }
		91	+
		92	+ inline const std::string& GetStatus() const
		93	+ {
		94	+ return m_status;
		95	+ }
		96	+
		97	+ inline void SetStatus( const std::string &status )
		98	+ {
		99	+ m_status = status;
		100	+ }
		101	+
		102	+ inline int GetSum() const
		103	+ {
		104	+ return m_sum;
		105	+ }
		106	+
		107	+ inline void SetSum( int sum )
		108	+ {
		109	+ m_sum = sum;
		110	+ }
		111	+
		112	+ inline const std::vector< DeviceInfo >& GetDevices() const
		113	+ {
		114	+ return m_devices;
		115	+ }
		116	+
		117	+ inline void AddEvent(const std::string &id, EEventType eventType)
		118	+ {
		119	+ DeviceInfo catalog;
		120	+ catalog.id = id;
		121	+ catalog.event = eventType;
		122	+ m_devices.push_back( catalog );
		123	+ }
		124	+
		125	+ inline void AddOnEvent( const std::string &id )
		126	+ {
		127	+ DeviceInfo catalog;
		128	+ catalog.id = id;
		129	+ catalog.event = EVENT_ON;
		130	+ m_devices.push_back( catalog );
		131	+ }
		132	+
		133	+ inline void AddOffEvent( const std::string &id )
		134	+ {
		135	+ DeviceInfo catalog;
		136	+ catalog.id = id;
		137	+ catalog.event = EVENT_OFF;
		138	+ m_devices.push_back( catalog );
		139	+ }
		140	+
		141	+ inline void AddVLostEvent( const std::string &id )
		142	+ {
		143	+ DeviceInfo catalog;
		144	+ catalog.id = id;
		145	+ catalog.event = EVENT_VLOST;
		146	+ m_devices.push_back( catalog );
		147	+ }
		148	+
		149	+ inline void AddDefectEvent( const std::string &id )
		150	+ {
		151	+ DeviceInfo catalog;
		152	+ catalog.id = id;
		153	+ catalog.event = EVENT_DEFECT;
		154	+ m_devices.push_back( catalog );
		155	+ }
		156	+
		157	+ inline void AddDelEvent( const std::string &id )
		158	+ {
		159	+ DeviceInfo catalog;
		160	+ catalog.id = id;
		161	+ catalog.event = EVENT_DEL;
		162	+ m_devices.push_back( catalog );
		163	+ }
		164	+
		165	+ inline void AddAddEvent( const DeviceInfo &catalog )
		166	+ {
		167	+ if( catalog.event == EVENT_ADD )
		168	+ {
		169	+ m_devices.push_back( catalog );
		170	+ }
		171	+ }
		172	+
		173	+ inline void AddUpdateEvent( const DeviceInfo &catalog )
		174	+ {
		175	+ if( catalog.event == EVENT_UPDATE )
		176	+ {
		177	+ m_devices.push_back( catalog );
		178	+ }
		179	+ }
		180	+
		181	+private:
		182	+ std::vector< DeviceInfo > Decode(const std::vector< tinyxml2::XMLNode* >& nodes);
		183	+ string getItemValue(tinyxml2::XMLNode *pItem);
		184	+
		185	+private:
		186	+ std::string m_sn;
		187	+ std::string m_deviceid;
		188	+ std::string m_status;
		189	+ int m_sum;
		190	+ std::vector< DeviceInfo > m_devices;
		191	+};
		192	+
		193	+#endif // MSG_NOTIFY_MSG_HPP_
0	\ No newline at end of file	194	\ No newline at end of file

sip/Message/GBMessage.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/Message/GBMessage.cpp
		1	+#include "GBMessage.h"
		2	+//#include "ILocker.h"
		3	+#include <atomic>
		4	+static std::atomic<unsigned int> g_msgsn(0);
		5	+//static CLocker g_msg_lock;
		6	+
		7	+bool CGBMessage::CompareNoCase( const char type, const char label )
		8	+{
		9	+ // 参数校验
		10	+ if( type == NULL \|\| label == NULL )
		11	+ {
		12	+ return false;
		13	+ }
		14	+
		15	+ // 比较是否相等
		16	+ char ch1 = type[0];
		17	+ char ch2 = label[0];
		18	+ size_t i = 0;
		19	+ while( ch1 != 0 && ch2 != 0 )
		20	+ {
		21	+ if( ch1 >= 'a' && ch1 <= 'z' )
		22	+ {
		23	+ ch1 -= 'a';
		24	+ ch1 += 'A';
		25	+ }
		26	+
		27	+ if( ch2 >= 'a' && ch2 <= 'z' )
		28	+ {
		29	+ ch2 -= 'a';
		30	+ ch2 += 'A';
		31	+ }
		32	+
		33	+ if( ch1 != ch2 )
		34	+ {
		35	+ return false;
		36	+ }
		37	+ else
		38	+ {
		39	+ ++i;
		40	+ ch1 = type[i];
		41	+ ch2 = label[i];
		42	+ }
		43	+ }
		44	+
		45	+ return( ch1 == 0 && ch2 == 0 );
		46	+}
		47	+
		48	+
		49	+bool CGBMessage::CompareNoCase( const std::string &str, const char *label )
		50	+{
		51	+ // 参数校验
		52	+ const char* type = str.c_str();
		53	+ if( type == NULL \|\| label == NULL )
		54	+ {
		55	+ return false;
		56	+ }
		57	+
		58	+ // 比较是否相等
		59	+ char ch1 = type[0];
		60	+ char ch2 = label[0];
		61	+ size_t i = 0;
		62	+ while( ch1 != 0 && ch2 != 0 )
		63	+ {
		64	+ if( ch1 >= 'a' && ch1 <= 'z' )
		65	+ {
		66	+ ch1 -= 'a';
		67	+ ch1 += 'A';
		68	+ }
		69	+
		70	+ if( ch2 >= 'a' && ch2 <= 'z' )
		71	+ {
		72	+ ch2 -= 'a';
		73	+ ch2 += 'A';
		74	+ }
		75	+
		76	+ if( ch1 != ch2 )
		77	+ {
		78	+ return false;
		79	+ }
		80	+ else
		81	+ {
		82	+ ++i;
		83	+ ch1 = type[i];
		84	+ ch2 = label[i];
		85	+ }
		86	+ }
		87	+
		88	+ return( ch1 == 0 && ch2 == 0 );
		89	+}
		90	+
		91	+unsigned int CGBMessage::GetNextSN()
		92	+{
		93	+ //CNPAutoLock locker( g_msg_lock );
		94	+ g_msgsn++;
		95	+ return g_msgsn;
		96	+}
		97	+
		98	+bool CGBMessage::DecodeSubject()
		99	+{
		100	+ std::vector< std::string > vec;
		101	+ size_t b = 0;
		102	+ size_t e = 0;
		103	+ while( b != std::string::npos )
		104	+ {
		105	+ e = m_subject.find_first_of( ',', b );
		106	+ vec.push_back( m_subject.substr( b, e ) );
		107	+ if( e != std::string::npos )
		108	+ {
		109	+ b = e + 1;
		110	+ }
		111	+ else
		112	+ {
		113	+ break;
		114	+ }
		115	+ }
		116	+
		117	+ if( vec.size() != 2 )
		118	+ {
		119	+ return false;
		120	+ }
		121	+
		122	+ //
		123	+ std::string send = vec[0];
		124	+ std::string recv = vec[1];
		125	+
		126	+ // 发送者ID和序列号
		127	+ vec.clear();
		128	+ b = 0;
		129	+ while( b != std::string::npos )
		130	+ {
		131	+ e = send.find_first_of( ':', b );
		132	+ vec.push_back( send.substr( b, e ) );
		133	+ if( e != std::string::npos )
		134	+ {
		135	+ b = e + 1;
		136	+ }
		137	+ else
		138	+ {
		139	+ break;
		140	+ }
		141	+ }
		142	+
		143	+ if( vec.size() != 2 )
		144	+ {
		145	+ return false;
		146	+ }
		147	+ else
		148	+ {
		149	+ m_sender.id = vec[0];
		150	+ m_sender.seq = vec[1];
		151	+ }
		152	+
		153	+ // 接收者ID和序列号
		154	+ vec.clear();
		155	+ b = 0;
		156	+ while( b != std::string::npos )
		157	+ {
		158	+ e = recv.find_first_of( ':', b );
		159	+ vec.push_back( recv.substr( b, e ) );
		160	+ if( e != std::string::npos )
		161	+ {
		162	+ b = e + 1;
		163	+ }
		164	+ else
		165	+ {
		166	+ break;
		167	+ }
		168	+ }
		169	+
		170	+ if( vec.size() != 2 )
		171	+ {
		172	+ return false;
		173	+ }
		174	+ else
		175	+ {
		176	+ m_recver.id = vec[0];
		177	+ m_recver.seq = vec[1];
		178	+ }
		179	+
		180	+ return true;
		181	+}
		182	+

sip/Message/GBMessage.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/Message/GBMessage.h
		1	+#ifndef GBMESSAGE_HPP_
		2	+#define GBMESSAGE_HPP_
		3	+
		4	+#include <sstream>
		5	+#include <iostream>
		6	+#include <string>
		7	+#include <vector>
		8	+#include "../tinyxml2/tinyxml2.h"
		9	+
		10	+
		11	+#if defined(CATCH_RESIP_EXCEPTION)
		12	+#undef __DUM_TRY
		13	+#undef __DUM_CATCH
		14	+#define __DUM_TRY try {
		15	+#define __DUM_CATCH \
		16	+} catch(resip::DumException* be) { \
		17	+ resip::Data ex; \
		18	+ ex = "RESIP ��쳣��name = "; \
		19	+ ex += be->name(); \
		20	+ ex += "��what = "; \
		21	+ ex += be->what(); \
		22	+ throw new std::exception(ex.c_str()); \
		23	+}
		24	+#else
		25	+#undef __DUM_TRY
		26	+#undef __DUM_CATCH
		27	+#define __DUM_TRY
		28	+#define __DUM_CATCH
		29	+#endif
		30	+
		31	+
		32	+class CGBMessage
		33	+{
		34	+public:
		35	+ enum EGBResultType
		36	+ {
		37	+ RESULT_OK = 0,
		38	+ RESULT_ERROR,
		39	+ };
		40	+
		41	+ struct SDate
		42	+ {
		43	+ int year;
		44	+ int month;
		45	+ int day;
		46	+ int hour;
		47	+ int minute;
		48	+ int second;
		49	+ int millisecond;
		50	+ };
		51	+
		52	+ struct SSubject
		53	+ {
		54	+ std::string id;
		55	+ std::string seq;
		56	+ };
		57	+
		58	+ struct SUserIdentity
		59	+ {
		60	+ std::string user;
		61	+ std::string deviceid;
		62	+ std::string organization;
		63	+ std::string policetype;
		64	+ std::string duty;
		65	+ };
		66	+
		67	+public:
		68	+ CGBMessage() : m_adjusttime( false ), m_port( 0 ), m_cseq( 0 ), m_forwards( 0 ), m_expires( 0 ), m_statusCode( 0 )
		69	+ {
		70	+ }
		71	+
		72	+ virtual ~CGBMessage()
		73	+ {
		74	+ }
		75	+
		76	+private:
		77	+ CGBMessage( const CGBMessage &rhs );
		78	+ CGBMessage& operator=( const CGBMessage &rhs );
		79	+
		80	+public:
		81	+ inline bool Ok() const
		82	+ {
		83	+ return( m_statusCode == 200 );
		84	+ }
		85	+
		86	+ inline bool AdjustTime() const
		87	+ {
		88	+ return m_adjusttime;
		89	+ }
		90	+
		91	+ inline const std::string& GetSubjectSendID() const
		92	+ {
		93	+ return m_sender.id;
		94	+ }
		95	+
		96	+ inline const std::string& GetSubjectSendSeq() const
		97	+ {
		98	+ return m_sender.seq;
		99	+ }
		100	+
		101	+ inline const std::string& GetSubjectRecvID() const
		102	+ {
		103	+ return m_recver.id;
		104	+ }
		105	+
		106	+ inline const std::string& GetSubjectRecvSeq() const
		107	+ {
		108	+ return m_recver.seq;
		109	+ }
		110	+
		111	+ inline const std::string& GetUser() const
		112	+ {
		113	+ return m_request;
		114	+ }
		115	+
		116	+ inline const std::string& GetSubject() const
		117	+ {
		118	+ return m_subject;
		119	+ }
		120	+
		121	+ inline const std::string& GetFrom() const
		122	+ {
		123	+ return m_from;
		124	+ }
		125	+
		126	+ inline const std::string& GetFromTag() const
		127	+ {
		128	+ return m_tagfrom;
		129	+ }
		130	+
		131	+ inline const std::string& GetTo() const
		132	+ {
		133	+ return m_to;
		134	+ }
		135	+
		136	+ inline const std::string& GetToTag() const
		137	+ {
		138	+ return m_tagto;
		139	+ }
		140	+
		141	+ inline unsigned long GetCSeq() const
		142	+ {
		143	+ return m_cseq;
		144	+ }
		145	+
		146	+ inline int GetStatusCode() const
		147	+ {
		148	+ return m_statusCode;
		149	+ }
		150	+
		151	+ inline int GetMaxFrowards() const
		152	+ {
		153	+ return m_forwards;
		154	+ }
		155	+
		156	+ inline int GetExpires() const
		157	+ {
		158	+ return m_expires;
		159	+ }
		160	+
		161	+ inline const std::string& GetIP() const
		162	+ {
		163	+ return m_ip;
		164	+ }
		165	+
		166	+ inline int GetPort() const
		167	+ {
		168	+ return m_port;
		169	+ }
		170	+
		171	+ inline const std::string& GetCallID() const
		172	+ {
		173	+ return m_callid;
		174	+ }
		175	+
		176	+ inline const SDate& GetDate() const
		177	+ {
		178	+ return m_date;
		179	+ }
		180	+
		181	+ inline const SUserIdentity& GetUserIdentity() const
		182	+ {
		183	+ return m_useridentity;
		184	+ }
		185	+
		186	+ inline const std::vector< std::string >& GetContacts() const
		187	+ {
		188	+ return m_contacts;
		189	+ }
		190	+
		191	+ inline const std::vector< std::string >& GetVias() const
		192	+ {
		193	+ return m_vias;
		194	+ }
		195	+
		196	+ inline void SetSubjectSendID( const std::string &id )
		197	+ {
		198	+ m_sender.id = id;
		199	+ }
		200	+
		201	+ inline void SetSubjectSendSeq( const std::string &seq )
		202	+ {
		203	+ m_sender.seq = seq;
		204	+ }
		205	+
		206	+ inline void SetSubjectRecvID( const std::string &id )
		207	+ {
		208	+ m_recver.id = id;
		209	+ }
		210	+
		211	+ inline void SetSubjectRecvSeq( const std::string &seq )
		212	+ {
		213	+ m_recver.seq = seq;
		214	+ }
		215	+
		216	+ inline void SetUser( const char *user )
		217	+ {
		218	+ if( user != NULL )
		219	+ {
		220	+ m_request = user;
		221	+ }
		222	+ }
		223	+
		224	+ inline void SetUser( const std::string &user )
		225	+ {
		226	+ m_request = user;
		227	+ }
		228	+
		229	+ inline void SetSubject( const char *uri )
		230	+ {
		231	+ if( uri != NULL )
		232	+ {
		233	+ m_subject = uri;
		234	+ DecodeSubject();
		235	+ }
		236	+ }
		237	+
		238	+ inline void SetSubject( const std::string &uri )
		239	+ {
		240	+ m_subject = uri;
		241	+ DecodeSubject();
		242	+ }
		243	+
		244	+ inline void SetFrom( const char *code )
		245	+ {
		246	+ if( code != NULL )
		247	+ {
		248	+ m_from = code;
		249	+ }
		250	+ }
		251	+
		252	+ inline void SetFrom( const std::string &code )
		253	+ {
		254	+ m_from = code;
		255	+ }
		256	+
		257	+ inline void SetFromTag( const char *tag )
		258	+ {
		259	+ if( tag != NULL )
		260	+ {
		261	+ m_tagfrom = tag;
		262	+ }
		263	+ }
		264	+
		265	+ inline void SetFromTag( const std::string &code )
		266	+ {
		267	+ m_tagfrom = code;
		268	+ }
		269	+
		270	+ inline void SetTo( const char *code )
		271	+ {
		272	+ if( code != NULL )
		273	+ {
		274	+ m_to = code;
		275	+ }
		276	+ }
		277	+
		278	+ inline void SetTo( const std::string &code )
		279	+ {
		280	+ m_to = code;
		281	+ }
		282	+
		283	+ inline void SetToTag( const char *tag )
		284	+ {
		285	+ if( tag != NULL )
		286	+ {
		287	+ m_tagto = tag;
		288	+ }
		289	+ }
		290	+
		291	+ inline void SetToTag( const std::string &tag )
		292	+ {
		293	+ m_tagto = tag;
		294	+ }
		295	+
		296	+ inline void SetCSeq( unsigned long cseq )
		297	+ {
		298	+ m_cseq = cseq;
		299	+ }
		300	+
		301	+ inline void SetExpires( int expires )
		302	+ {
		303	+ m_expires = expires;
		304	+ }
		305	+
		306	+ inline void SetStatusCode( int code )
		307	+ {
		308	+ m_statusCode = code;
		309	+ }
		310	+
		311	+ inline void SetMaxFrowards( int forwards )
		312	+ {
		313	+ m_forwards = forwards;
		314	+ }
		315	+
		316	+ inline void SetCallID( const char *callid )
		317	+ {
		318	+ if( callid != NULL )
		319	+ {
		320	+ m_callid = callid;
		321	+ }
		322	+ }
		323	+
		324	+ inline void SetCallID( const std::string &callid )
		325	+ {
		326	+ m_callid = callid;
		327	+ }
		328	+
		329	+ inline void SetIP( const std::string &ip )
		330	+ {
		331	+ m_ip = ip;
		332	+ }
		333	+
		334	+ inline void SetIP( const char *ip )
		335	+ {
		336	+ if( ip != NULL )
		337	+ {
		338	+ m_ip = ip;
		339	+ }
		340	+ }
		341	+
		342	+ inline void SetPort( int port )
		343	+ {
		344	+ m_port = port;
		345	+ }
		346	+
		347	+ inline void SetDate( int year, int month, int day, int hour, int minute, int second, int millisecond )
		348	+ {
		349	+ m_adjusttime = true;
		350	+ m_date.year = year;
		351	+ m_date.month = month;
		352	+ m_date.day = day;
		353	+ m_date.hour = hour;
		354	+ m_date.minute = minute;
		355	+ m_date.second = second;
		356	+ m_date.millisecond = millisecond;
		357	+ }
		358	+
		359	+ inline void AddContacts( const char *contacts )
		360	+ {
		361	+ if( contacts != NULL )
		362	+ {
		363	+ m_contacts.push_back( contacts );
		364	+ }
		365	+ }
		366	+
		367	+ inline void AddContacts( const std::string &contacts )
		368	+ {
		369	+ m_contacts.push_back( contacts );
		370	+ }
		371	+
		372	+ inline void AddVias( const char *host, long port )
		373	+ {
		374	+ if( host != NULL )
		375	+ {
		376	+ char buf[16] = { 0 };
		377	+ sprintf( buf, "%ld", port );
		378	+ std::string via = host;
		379	+ via += ":";
		380	+ via += buf;
		381	+ m_vias.push_back( via );
		382	+ }
		383	+ }
		384	+
		385	+ inline void AddVias( const std::string &host, long port )
		386	+ {
		387	+ char buf[16] = { 0 };
		388	+ sprintf( buf, "%ld", port );
		389	+ std::string via = host;
		390	+ via += ":";
		391	+ via += buf;
		392	+ m_vias.push_back( via );
		393	+ }
		394	+
		395	+ inline void SetUserIdentity( const std::string &user, const std::string& deviceid, const std::string& organization, const std::string& policetype, const std::string& duty )
		396	+ {
		397	+ m_useridentity.user = user;
		398	+ m_useridentity.deviceid = deviceid;
		399	+ m_useridentity.organization = organization;
		400	+ m_useridentity.policetype = policetype;
		401	+ m_useridentity.duty = duty;
		402	+ }
		403	+
		404	+public:
		405	+
		406	+ virtual bool Response( int status )
		407	+ {
		408	+ return false;
		409	+ }
		410	+
		411	+public:
		412	+ static bool CompareNoCase( const char type, const char label );
		413	+ static bool CompareNoCase( const std::string &type, const char *label );
		414	+ static unsigned int GetNextSN();
		415	+ bool DecodeSubject();
		416	+
		417	+protected:
		418	+ SSubject m_sender; // subject
		419	+ SSubject m_recver; // subject
		420	+ std::string m_request;
		421	+ std::string m_subject;
		422	+ std::string m_callid;
		423	+ std::string m_from;
		424	+ std::string m_tagfrom;
		425	+ std::string m_to;
		426	+ std::string m_tagto;
		427	+ SDate m_date;
		428	+ std::vector< std::string > m_contacts;
		429	+ std::vector< std::string > m_vias;
		430	+ std::string m_ip;
		431	+ bool m_adjusttime; // message has date header
		432	+ int m_port;
		433	+ unsigned long m_cseq;
		434	+ int m_forwards;
		435	+ int m_expires;
		436	+ int m_statusCode;
		437	+ SUserIdentity m_useridentity;
		438	+};
		439	+
		440	+//////////////////////////////////////////////////////////////////////////
		441	+#endif // GBMESSAGE_HPP_

sip/SipServer.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/SipServer.cpp
		1	+//
		2	+// Created bxc on 2022/11/25.
		3	+//
		4	+
		5	+#include "SipServer.h"
		6	+
		7	+#ifndef WIN32
		8	+// Linux系统
		9	+#include <arpa/inet.h>
		10	+#else
		11	+#include <WinSock2.h>
		12	+#pragma comment(lib, "ws2_32.lib")
		13	+#endif // !WIN32
		14	+
		15	+#include <cstring>
		16	+#include "./Utils/HTTPDigest.h"
		17	+#include "./Utils/Utools.hpp"
		18	+#include "./Utils/logger.hpp"
		19	+#include "./Utils/StringTools.hpp"
		20	+
		21	+
		22	+#include <sstream>
		23	+#include <algorithm>
		24	+
		25	+
		26	+using namespace std;
		27	+
		28	+static void event_loop_thread(void* arg) {
		29	+ SipServer* _this = (SipServer*)arg;
		30	+ if (_this != nullptr) {
		31	+ _this->event_loop();
		32	+ }
		33	+ else {
		34	+ LOG_ERROR("event_loop线程启动失败 !");
		35	+ }
		36	+}
		37	+
		38	+static void timing_getcatlog_thread(void* arg) {
		39	+ SipServer* _this = (SipServer*)arg;
		40	+ if (_this != nullptr) {
		41	+ _this->timing_getcatlog();
		42	+ }
		43	+ else {
		44	+ LOG_ERROR("timing_getcatlog 线程启动失败 !");
		45	+ }
		46	+}
		47	+
		48	+static void dt_printSipMsg(osip_message_t* msg) {
		49	+ osip_message_t* clone_event = NULL;
		50	+ size_t length = 0;
		51	+ char* message = NULL;
		52	+ osip_message_clone(msg, &clone_event);
		53	+ osip_message_to_str(clone_event, &message, &length);
		54	+ LOG_INFO("{}", message);
		55	+}
		56	+
		57	+SipServer::SipServer():
		58	+ mQuit(false),
		59	+ mSipCtx(nullptr){
		60	+#ifdef WIN32
		61	+ WSADATA wsaData;
		62	+ if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
		63	+ {
		64	+ LOG_ERROR("WSAStartup Error");
		65	+ return;
		66	+ }
		67	+#endif // WIN32
		68	+
		69	+}
		70	+SipServer::~SipServer() {
		71	+ LOG_INFO("~SipServer");
		72	+
		73	+ if (m_event_loop_thread)
		74	+ {
		75	+ mQuit = true;
		76	+ m_event_loop_thread->join();
		77	+
		78	+ delete m_event_loop_thread;
		79	+ m_event_loop_thread = nullptr;
		80	+ }
		81	+
		82	+ this->clearClientMap();
		83	+#ifdef WIN32
		84	+ WSACleanup();
		85	+#endif // WIN32
		86	+}
		87	+
		88	+bool SipServer::Init(ServerInfo* pInfo) {
		89	+
		90	+ if (pInfo == nullptr) {
		91	+ return false;
		92	+ }
		93	+
		94	+ mInfo = *pInfo;
		95	+
		96	+ m_event_loop_thread = new std::thread(event_loop_thread, this);
		97	+
		98	+ return true;
		99	+}
		100	+
		101	+int SipServer::sip_event_handle(eXosip_event_t *evtp) {
		102	+
		103	+ switch(evtp->type) {
		104	+ case EXOSIP_CALL_MESSAGE_NEW://14
		105	+ // LOG_INFO("EXOSIP_CALL_MESSAGE_NEW type={}", evtp->type);
		106	+ this->dump_request(evtp);
		107	+ this->dump_response(evtp);
		108	+ break;
		109	+
		110	+ case EXOSIP_CALL_CLOSED://21
		111	+ LOG_INFO("EXOSIP_CALL_CLOSED type={}",evtp->type);
		112	+ this->dump_request(evtp);
		113	+ this->dump_response(evtp);
		114	+ break;
		115	+
		116	+ case EXOSIP_CALL_RELEASED://22
		117	+ LOG_INFO("EXOSIP_CALL_RELEASED type={}", evtp->type);
		118	+ this->dump_request(evtp);
		119	+ this->dump_response(evtp);
		120	+
		121	+ // this->clearClientMap();
		122	+ break;
		123	+ case EXOSIP_MESSAGE_NEW://23
		124	+ // LOG_INFO("EXOSIP_MESSAGE_NEW type={}",evtp->type);
		125	+
		126	+ if (MSG_IS_REGISTER(evtp->request)) {
		127	+ this->response_register(evtp);
		128	+ }
		129	+ else if (MSG_IS_MESSAGE(evtp->request)) {
		130	+ this->response_message(evtp);
		131	+ }
		132	+ else if(MSG_IS_BYE(evtp->request)){
		133	+ LOG_ERROR("BYE");
		134	+ }
		135	+ else{
		136	+ LOG_ERROR("unknown2");
		137	+ }
		138	+ break;
		139	+ case EXOSIP_MESSAGE_ANSWERED:
		140	+ this->dump_request(evtp);
		141	+ break;
		142	+ case EXOSIP_MESSAGE_REQUESTFAILURE:
		143	+ LOG_INFO("EXOSIP_MESSAGE_REQUESTFAILURE type={}: Receive feedback on sending failure after actively sending a message", evtp->type);
		144	+ this->dump_request(evtp);
		145	+ this->dump_response(evtp);
		146	+ break;
		147	+ case EXOSIP_CALL_INVITE:
		148	+ LOG_INFO("EXOSIP_CALL_INVITE type={}: The server receives the Invite request actively sent by the client", evtp->type);
		149	+ break;
		150	+ case EXOSIP_CALL_PROCEEDING://5
		151	+ LOG_INFO("EXOSIP_CALL_PROCEEDING type={}: When the server receives the Invite (SDP) confirmation reply from the client", evtp->type);
		152	+ this->dump_request(evtp);
		153	+ this->dump_response(evtp);
		154	+ break;
		155	+ case EXOSIP_CALL_ANSWERED:// 7
		156	+ LOG_INFO("EXOSIP_CALL_ANSWERED type={}: The server receives an invite (SDP) confirmation reply from the client", evtp->type);
		157	+ this->dump_request(evtp);
		158	+ this->dump_response(evtp);
		159	+
		160	+ this->response_invite_ack(evtp);
		161	+ cache_invite_callinfo(evtp);
		162	+ break;
		163	+ case EXOSIP_CALL_SERVERFAILURE:
		164	+ LOG_INFO("EXOSIP_CALL_SERVERFAILURE type={}", evtp->type);
		165	+ break;
		166	+ case EXOSIP_IN_SUBSCRIPTION_NEW:
		167	+ LOG_INFO("EXOSIP_IN_SUBSCRIPTION_NEW type={}", evtp->type);
		168	+ break;
		169	+ default:
		170	+ LOG_INFO("type={} unknown", evtp->type);
		171	+ break;
		172	+ }
		173	+
		174	+ return 0;
		175	+}
		176	+
		177	+string contract_ip_from_message(string str_msg) {
		178	+
		179	+ str_msg = StringTools::to_lower(str_msg);
		180	+
		181	+ string c = str_msg.substr(str_msg.find("c=")+2);
		182	+ string c1 = c.substr(0, c.find_first_of("=") - 1);
		183	+ string c2 = c1.substr(c1.find_first_of("4")+1);
		184	+
		185	+ return StringTools::trim(c2);
		186	+}
		187	+
		188	+string contract_port_from_message(string str_msg) {
		189	+
		190	+ str_msg = StringTools::to_lower(str_msg);
		191	+
		192	+ string c = str_msg.substr(str_msg.find("video")+6);
		193	+ string c1 = c.substr(0, c.find_first_of(" "));
		194	+
		195	+ return StringTools::trim(c1);
		196	+}
		197	+
		198	+void SipServer::cache_invite_callinfo(eXosip_event_t *evtp) {
		199	+ CallInfo call_info;
		200	+ call_info.cid = evtp->cid;
		201	+ call_info.did = evtp->did;
		202	+
		203	+ try
		204	+ {
		205	+ char *s;
		206	+ size_t len;
		207	+ osip_message_to_str(evtp->request, &s, &len);
		208	+
		209	+ string ip = contract_ip_from_message(s);
		210	+ string port = contract_port_from_message(s);
		211	+
		212	+ std::cout << "ip:" << ip << " port:" << port << std::endl;
		213	+
		214	+ string channel_id = evtp->response->to->url->username;
		215	+
		216	+ auto key = std::make_tuple(channel_id, ip, atoi(port.c_str()));
		217	+ m_invite_callinfo_map[key] = call_info;
		218	+ }
		219	+ catch(const std::exception& e)
		220	+ {
		221	+ std::cerr << e.what() << '\n';
		222	+ }
		223	+}
		224	+
		225	+int SipServer::init_sip_server() {
		226	+ mSipCtx = eXosip_malloc();
		227	+ if (!mSipCtx) {
		228	+ LOG_ERROR("eXosip_malloc error");
		229	+ return -1;
		230	+ }
		231	+ if (eXosip_init(mSipCtx)) {
		232	+ LOG_ERROR("eXosip_init error");
		233	+ return -1;
		234	+ }
		235	+ if (eXosip_listen_addr(mSipCtx, IPPROTO_UDP, nullptr, mInfo.getPort(), AF_INET, 0)) {
		236	+ LOG_ERROR("eXosip_listen_addr error");
		237	+ return -1;
		238	+ }
		239	+ eXosip_set_user_agent(mSipCtx, mInfo.getUa().c_str());
		240	+ if (eXosip_add_authentication_info(mSipCtx, mInfo.getSipId().c_str(), mInfo.getSipId().c_str(), mInfo.getSipPass().c_str(), NULL, mInfo.getSipRealm().c_str())) {
		241	+ LOG_ERROR("eXosip_add_authentication_info error");
		242	+ return -1;
		243	+ }
		244	+
		245	+ return 0;
		246	+}
		247	+
		248	+void SipServer::event_loop() {
		249	+
		250	+ if(this->init_sip_server() !=0 ){
		251	+ return;
		252	+ }
		253	+
		254	+ LOG_INFO("sip server init succeed: {}:{}", mInfo.getIp(), mInfo.getPort());
		255	+
		256	+ // thread* timing_getcatlog_threadptr = new std::thread(timing_getcatlog_thread, this);
		257	+
		258	+ while(!mQuit) {
		259	+ eXosip_event_t *evtp = eXosip_event_wait(mSipCtx, 0, 20);
		260	+ if (!evtp){
		261	+ eXosip_automatic_action(mSipCtx);
		262	+ osip_usleep(100000);
		263	+ continue;
		264	+ }
		265	+ eXosip_automatic_action(mSipCtx);
		266	+ this->sip_event_handle(evtp);
		267	+ eXosip_event_free(evtp);
		268	+ }
		269	+
		270	+ mQuit = true;
		271	+ // if (timing_getcatlog_threadptr) {
		272	+ // timing_getcatlog_threadptr->join();
		273	+ // delete timing_getcatlog_threadptr;
		274	+ // timing_getcatlog_threadptr = nullptr;
		275	+ // }
		276	+}
		277	+
		278	+void SipServer::Close() {
		279	+ mQuit = true;
		280	+
		281	+ if (m_event_loop_thread) {
		282	+ m_event_loop_thread->join();
		283	+ delete m_event_loop_thread;
		284	+ m_event_loop_thread = nullptr;
		285	+ }
		286	+
		287	+}
		288	+
		289	+void SipServer::timing_getcatlog() {
		290	+ while(!mQuit) {
		291	+ // 5分钟更新一次
		292	+ std::this_thread::sleep_for(std::chrono::minutes(5));
		293	+ cacheCatalog();
		294	+ }
		295	+}
		296	+
		297	+void SipServer::response_message_answer(eXosip_event_t *evtp,int code){
		298	+
		299	+ int returnCode = 0 ;
		300	+ osip_message_t * pRegister = nullptr;
		301	+ returnCode = eXosip_message_build_answer (mSipCtx,evtp->tid,code,&pRegister);
		302	+ bool bRegister = false;
		303	+ if(pRegister){
		304	+ bRegister = true;
		305	+ }
		306	+ if (returnCode == 0 && bRegister)
		307	+ {
		308	+ eXosip_lock(mSipCtx);
		309	+ eXosip_message_send_answer (mSipCtx,evtp->tid,code,pRegister);
		310	+ eXosip_unlock(mSipCtx);
		311	+ }
		312	+ else{
		313	+ LOG_ERROR("code={},returnCode={},bRegister={}",code,returnCode,bRegister);
		314	+ }
		315	+
		316	+}
		317	+void SipServer::response_register(eXosip_event_t *evtp) {
		318	+
		319	+ osip_authorization_t * auth = nullptr;
		320	+ osip_message_get_authorization(evtp->request, 0, &auth);
		321	+
		322	+ if(auth && auth->username){
		323	+
		324	+ char *method = NULL, // REGISTER
		325	+ *algorithm = NULL, // MD5
		326	+ *username = NULL,// 340200000013200000024
		327	+ *realm = NULL, // sip服务器传给客户端，客户端携带并提交上来的sip服务域
		328	+ *nonce = NULL, //sip服务器传给客户端，客户端携带并提交上来的nonce
		329	+ *nonce_count = NULL,
		330	+ *uri = NULL; // sip:34020000002000000001@3402000000
		331	+
		332	+ osip_contact_t *contact = nullptr;
		333	+ osip_message_get_contact (evtp->request, 0, &contact);
		334	+
		335	+ method = evtp->request->sip_method;
		336	+ char calc_response[HASHHEXLEN];
		337	+ HASHHEX HA1, HA2 = "", Response;
		338	+
		339	+#define SIP_STRDUP(field) if (auth->field) (field) = osip_strdup_without_quote(auth->field)
		340	+
		341	+ SIP_STRDUP(algorithm);
		342	+ SIP_STRDUP(username);
		343	+ SIP_STRDUP(realm);
		344	+ SIP_STRDUP(nonce);
		345	+ SIP_STRDUP(nonce_count);
		346	+ SIP_STRDUP(uri);
		347	+
		348	+ DigestCalcHA1(algorithm, username, realm, mInfo.getSipPass().c_str(), nonce, nonce_count, HA1);
		349	+ DigestCalcResponse(HA1, nonce, nonce_count, auth->cnonce, auth->message_qop, 0, method, uri, HA2, Response);
		350	+
		351	+ HASHHEX temp_HA1;
		352	+ HASHHEX temp_response;
		353	+ DigestCalcHA1("REGISTER", username, mInfo.getSipRealm().c_str(), mInfo.getSipPass().c_str(), mInfo.getNonce().c_str(), NULL, temp_HA1);
		354	+ DigestCalcResponse(temp_HA1, mInfo.getNonce().c_str(), NULL, NULL, NULL, 0, method, uri, NULL, temp_response);
		355	+ memcpy(calc_response, temp_response, HASHHEXLEN);
		356	+
		357	+
		358	+
		359	+ if (!memcmp(calc_response, Response, HASHHEXLEN)) {
		360	+ this->response_message_answer(evtp,200);
		361	+
		362	+ Client* client = new Client(strdup(contact->url->host),
		363	+ atoi(contact->url->port),
		364	+ strdup(username));
		365	+
		366	+ LOG_INFO("Camera registration succee,ip={},port={},device={}",client->getIp(),client->getPort(),client->getDevice());
		367	+
		368	+ deleteClientByDevice(client->getDevice());
		369	+
		370	+ std::lock_guard<std::mutex> l(m_client_map_mtx);
		371	+ mClientMap.insert(std::make_pair(client->getDevice(),client));
		372	+ // NVR注册成功，立即请求设备目录
		373	+ RequestCatalog(client);
		374	+
		375	+ } else {
		376	+ this->response_message_answer(evtp,401);
		377	+ LOG_INFO("Camera registration error, p={},port={},device={}", strdup(contact->url->host), atoi(contact->url->port), strdup(username));
		378	+ }
		379	+
		380	+ osip_free(algorithm);
		381	+ osip_free(username);
		382	+ osip_free(realm);
		383	+ osip_free(nonce);
		384	+ osip_free(nonce_count);
		385	+ osip_free(uri);
		386	+ } else {
		387	+ response_register_401unauthorized(evtp);
		388	+ }
		389	+
		390	+}
		391	+
		392	+void SipServer::response_register_401unauthorized(eXosip_event_t *evtp) {
		393	+
		394	+ char *dest = nullptr;
		395	+ osip_message_t * reg = nullptr;
		396	+ osip_www_authenticate_t * header = nullptr;
		397	+
		398	+ osip_www_authenticate_init(&header);
		399	+ osip_www_authenticate_set_auth_type (header, osip_strdup("Digest"));
		400	+ osip_www_authenticate_set_realm(header,osip_enquote(mInfo.getSipRealm().c_str()));
		401	+ osip_www_authenticate_set_nonce(header,osip_enquote(mInfo.getNonce().c_str()));
		402	+ osip_www_authenticate_to_str(header, &dest);
		403	+ int ret = eXosip_message_build_answer (mSipCtx, evtp->tid, 401, &reg);
		404	+ if ( ret == 0 && reg != nullptr ) {
		405	+ osip_message_set_www_authenticate(reg, dest);
		406	+ osip_message_set_content_type(reg, "Application/MANSCDP+xml");
		407	+ eXosip_lock(mSipCtx);
		408	+ eXosip_message_send_answer (mSipCtx, evtp->tid,401, reg);
		409	+ eXosip_unlock(mSipCtx);
		410	+ LOG_INFO("response_register_401unauthorized success");
		411	+ }else {
		412	+ LOG_INFO("response_register_401unauthorized error");
		413	+ }
		414	+
		415	+ osip_www_authenticate_free(header);
		416	+ osip_free(dest);
		417	+
		418	+}
		419	+
		420	+void printDevice(std::vector<DeviceInfo> vec_device) {
		421	+ LOG_INFO("-----start print----");
		422	+ for (size_t i = 0; i < vec_device.size(); i++) {
		423	+ LOG_INFO("{} {}", vec_device[i].id, vec_device[i].parentid);
		424	+ }
		425	+ LOG_INFO("-----end print----");
		426	+}
		427	+
		428	+void SipServer::response_message(eXosip_event_t *evtp) {
		429	+
		430	+ osip_body_t* body = nullptr;
		431	+ char CmdType[64] = {0};
		432	+ char DeviceID[64] = {0};
		433	+ osip_message_get_body(evtp->request, 0, &body);
		434	+ if(body){
		435	+ parse_xml(body->body, "<CmdType>", false, "</CmdType>", false, CmdType);
		436	+ parse_xml(body->body, "<DeviceID>", false, "</DeviceID>", false, DeviceID);
		437	+ }
		438	+
		439	+ if(!strcmp(CmdType, "Catalog")) {
		440	+ this->response_message_answer(evtp,200);
		441	+ // 需要根据对方的Catelog请求，做一些相应的应答请求
		442	+ CCatalogParser catPaser;
		443	+ std::vector<DeviceInfo> vec_device = catPaser.DecodeCatlog(body->body);
		444	+ printDevice(vec_device);
		445	+
		446	+ std::lock_guard<std::mutex> l(m_device_map_mtx);
		447	+ for (size_t i = 0; i < vec_device.size(); i++) {
		448	+ DeviceInfo info = vec_device[i];
		449	+ m_device_map[info.id] = info;
		450	+ }
		451	+ }
		452	+ else if(!strcmp(CmdType, "Keepalive")){
		453	+ this->response_message_answer(evtp,200);
		454	+ // LOG_INFO("CmdType={},DeviceID={}", CmdType, DeviceID);
		455	+ std::lock_guard<std::mutex> l_c(m_client_map_mtx);
		456	+ Client* client = mClientMap[DeviceID];
		457	+ if (client != nullptr) {
		458	+ client->updateHeartBeat(Utools::get_cur_time_ms());
		459	+ }
		460	+ }else{
		461	+ this->response_message_answer(evtp,200);
		462	+ }
		463	+}
		464	+
		465	+bool SipServer::check_device_status(string id) {
		466	+ std::lock_guard<std::mutex> l(m_device_map_mtx);
		467	+ auto it_info = m_device_map.find(id);
		468	+ if (it_info == m_device_map.end()) {
		469	+ return false;
		470	+ }
		471	+
		472	+ string status = StringTools::trim(it_info->second.status);
		473	+ transform(status.begin(), status.end(), status.begin(),::tolower);
		474	+ if (status == "on"){
		475	+ return true;
		476	+ }
		477	+
		478	+ return false;
		479	+}
		480	+
		481	+Client* SipServer::get_parent_by_id(string id) {
		482	+ std::lock_guard<std::mutex> l(m_device_map_mtx);
		483	+ auto it_info = m_device_map.find(id);
		484	+ if (it_info == m_device_map.end()) {
		485	+ return nullptr;
		486	+ }
		487	+ string parent_id = it_info->second.parentid;
		488	+
		489	+ std::lock_guard<std::mutex> l_c(m_client_map_mtx);
		490	+ auto it_client = mClientMap.find(parent_id);
		491	+ if (it_client == mClientMap.end()) {
		492	+ return nullptr;
		493	+ }
		494	+
		495	+ return mClientMap[parent_id];
		496	+}
		497	+
		498	+void SipServer::response_invite_ack(eXosip_event_t *evtp){
		499	+
		500	+ osip_message_t* msg = nullptr;
		501	+ int ret = eXosip_call_build_ack(mSipCtx, evtp->did, &msg);
		502	+ if (!ret && msg) {
		503	+ eXosip_call_send_ack(mSipCtx, evtp->did, msg);
		504	+ } else {
		505	+ LOG_ERROR("eXosip_call_send_ack error={}", ret);
		506	+ }
		507	+
		508	+}
		509	+int SipServer::request_bye(eXosip_event_t* evtp) {
		510	+
		511	+ eXosip_lock(mSipCtx);
		512	+ int ret = eXosip_call_terminate(mSipCtx, evtp->cid, evtp->did);
		513	+ eXosip_unlock(mSipCtx);
		514	+
		515	+ return ret;
		516	+}
		517	+
		518	+int SipServer::ByeInvite(std::string channel_id, string ip, int rtpPort) {
		519	+
		520	+ auto key = std::make_tuple(channel_id, ip, rtpPort);
		521	+
		522	+ auto it = m_invite_callinfo_map.find(key);
		523	+ if (it == m_invite_callinfo_map.end()) {
		524	+ return -1;
		525	+ }
		526	+
		527	+ CallInfo info = it->second;
		528	+
		529	+ eXosip_lock(mSipCtx);
		530	+ int ret = eXosip_call_terminate(mSipCtx, info.cid, info.did);
		531	+ eXosip_unlock(mSipCtx);
		532	+
		533	+ m_invite_callinfo_map.erase(it);
		534	+
		535	+ return 0;
		536	+}
		537	+
		538	+int SipServer::RequestInvite_UDP(const char* dst_channel, const char* rtpIp, int rtpPort) {
		539	+
		540	+ // 检查设备是否在线
		541	+ if (!check_device_status(dst_channel)) {
		542	+ LOG_ERROR("{} is not online!", dst_channel);
		543	+ return -2;
		544	+ }
		545	+
		546	+ Client* client = get_parent_by_id(dst_channel);
		547	+ if (client == nullptr) {
		548	+ LOG_ERROR("do not get parent device:{}", dst_channel);
		549	+ return -1;
		550	+ }
		551	+
		552	+ LOG_INFO("INVITE UDP: {} {}:{}", dst_channel, rtpIp, rtpPort);
		553	+
		554	+ char session_exp[1024] = { 0 };
		555	+ osip_message_t* msg = nullptr;
		556	+ char from[1024] = { 0 };
		557	+ char to[1024] = { 0 };
		558	+ char sdp[2048] = { 0 };
		559	+
		560	+ sprintf(from, "sip:%s@%s:%d", mInfo.getSipId().c_str(), mInfo.getIp().c_str(), mInfo.getPort());
		561	+ sprintf(to, "sip:%s@%s:%d", dst_channel, client->getIp().c_str(), client->getPort());
		562	+ snprintf(sdp, 2048,
		563	+ "v=0\r\n"
		564	+ "o=%s 0 0 IN IP4 %s\r\n"
		565	+ "s=Play\r\n"
		566	+ "c=IN IP4 %s\r\n"
		567	+ "t=0 0\r\n"
		568	+ "m=video %d RTP/AVP 96 98 97\r\n"
		569	+ "a=recvonly\r\n"
		570	+ "a=rtpmap:96 PS/90000\r\n"
		571	+ "a=rtpmap:98 H264/90000\r\n"
		572	+ "a=rtpmap:97 MPEG4/90000\r\n"
		573	+ "a=setup:passive\r\n"
		574	+ "a=connection:new\r\n"
		575	+ "y=0100000001\r\n"
		576	+ "f=\r\n", mInfo.getSipId().c_str(), rtpIp, rtpIp, rtpPort);
		577	+
		578	+ int ret = eXosip_call_build_initial_invite(mSipCtx, &msg, to, from, nullptr, nullptr);
		579	+ if (ret) {
		580	+ LOG_ERROR("eXosip_call_build_initial_invite error: {} {} ret:{}", from, to, ret);
		581	+ return -1;
		582	+ }
		583	+
		584	+ osip_message_set_body(msg, sdp, strlen(sdp));
		585	+ osip_message_set_content_type(msg, "application/sdp");
		586	+ snprintf(session_exp, sizeof(session_exp) - 1, "%i;refresher=uac", mInfo.getTimeout());
		587	+ osip_message_set_header(msg, "Session-Expires", session_exp);
		588	+ osip_message_set_supported(msg, "timer");
		589	+
		590	+ int call_id = eXosip_call_send_initial_invite(mSipCtx, msg);
		591	+ if (call_id > 0) {
		592	+ LOG_INFO("eXosip_call_send_initial_invite success: call_id={}", call_id);
		593	+ }
		594	+ else {
		595	+ LOG_ERROR("eXosip_call_send_initial_invite error: call_id={}", call_id);
		596	+ }
		597	+ return call_id;
		598	+}
		599	+
		600	+int SipServer::RequestInvite_TCP_a(const char* dst_channel, int rtpPort) {
		601	+ // 检查设备是否在线
		602	+ if (!check_device_status(dst_channel)) {
		603	+ return -2;
		604	+ }
		605	+
		606	+ Client* client = get_parent_by_id(dst_channel);
		607	+ if (client == nullptr) {
		608	+ return -1;
		609	+ }
		610	+
		611	+ LOG_INFO("INVITE TCP active");
		612	+
		613	+ char session_exp[1024] = { 0 };
		614	+ osip_message_t* msg = nullptr;
		615	+ char from[1024] = { 0 };
		616	+ char to[1024] = { 0 };
		617	+ char sdp[2048] = { 0 };
		618	+
		619	+ // const char* dst_channel = "34020000001320000001";
		620	+
		621	+ sprintf(from, "sip:%s@%s:%d", mInfo.getSipId().c_str(), mInfo.getIp().c_str(), mInfo.getPort());
		622	+ sprintf(to, "sip:%s@%s:%d", dst_channel, client->getIp().c_str(), client->getPort());
		623	+ snprintf(sdp, 2048,
		624	+ "v=0\r\n"
		625	+ "o=%s 0 0 IN IP4 %s\r\n"
		626	+ "s=Play\r\n"
		627	+ "c=IN IP4 %s\r\n"
		628	+ "t=0 0\r\n"
		629	+ "m=video %d TCP/RTP/AVP 96 98 97\r\n"
		630	+ "a=recvonly\r\n"
		631	+ "a=rtpmap:96 PS/90000\r\n"
		632	+ "a=rtpmap:98 H264/90000\r\n"
		633	+ "a=rtpmap:97 MPEG4/90000\r\n"
		634	+ "a=setup:active\r\n"
		635	+ "a=connection:new\r\n"
		636	+ "y=0100000001\r\n"
		637	+ "f=\r\n", mInfo.getSipId().c_str(), mInfo.getIp().c_str(), mInfo.getIp().c_str(), rtpPort);
		638	+
		639	+ int ret = eXosip_call_build_initial_invite(mSipCtx, &msg, to, from, nullptr, nullptr);
		640	+ if (ret) {
		641	+ LOG_ERROR("eXosip_call_build_initial_invite error: {} {} ret:{}", from, to, ret);
		642	+ return -1;
		643	+ }
		644	+
		645	+ osip_message_set_body(msg, sdp, strlen(sdp));
		646	+ osip_message_set_content_type(msg, "application/sdp");
		647	+ snprintf(session_exp, sizeof(session_exp) - 1, "%i;refresher=uac", mInfo.getTimeout());
		648	+ osip_message_set_header(msg, "Session-Expires", session_exp);
		649	+ osip_message_set_supported(msg, "timer");
		650	+
		651	+ int call_id = eXosip_call_send_initial_invite(mSipCtx, msg);
		652	+ if (call_id > 0) {
		653	+ LOG_INFO("eXosip_call_send_initial_invite success: call_id={}", call_id);
		654	+ }
		655	+ else {
		656	+ LOG_ERROR("eXosip_call_send_initial_invite error: call_id={}", call_id);
		657	+ }
		658	+ return call_id;
		659	+}
		660	+
		661	+void SipServer::cacheCatalog() {
		662	+
		663	+ std::lock_guard<std::mutex> l(m_client_map_mtx);
		664	+
		665	+ if (mClientMap.size() <= 0){
		666	+ cout << "no IPC" << endl;
		667	+ return ;
		668	+ }
		669	+
		670	+ cout << "client size:" << mClientMap.size() << endl;
		671	+ for (auto it = mClientMap.begin(); it != mClientMap.end(); it++) {
		672	+ RequestCatalog(it->second);
		673	+ }
		674	+}
		675	+
		676	+void SipServer::RequestCatalog(Client* client) {
		677	+
		678	+ eXosip_lock(mSipCtx);
		679	+
		680	+ osip_message_t* catlog_msg = NULL;
		681	+ char to[100];/sip:主叫用户名@被叫IP地址/
		682	+ char from[100];/sip:被叫IP地址:被叫IP端口/
		683	+ char xml_body[4096];
		684	+
		685	+ memset(to, 0, 100);
		686	+ memset(from, 0, 100);
		687	+ memset(xml_body, 0, 4096);
		688	+
		689	+ sprintf(from, "sip:%s@%s:%d", mInfo.getSipId().c_str(), mInfo.getIp().c_str(), mInfo.getPort());
		690	+ sprintf(to, "sip:%s@%s:%d", client->getDevice().c_str(), client->getIp().c_str(), client->getPort());
		691	+ eXosip_message_build_request(mSipCtx, &catlog_msg, "MESSAGE", to, from, NULL);/构建"MESSAGE"请求/
		692	+
		693	+ snprintf(xml_body, 4096,
		694	+ "<?xml version=\"1.0\"?>"
		695	+ "<Query>"
		696	+ "<CmdType>Catalog</CmdType>"
		697	+ "<SN>%d</SN>"
		698	+ "<DeviceID>%s</DeviceID>"
		699	+ "</Query>", rand() % (99999 - 10000 + 1) + 10000, client->getDevice().c_str());
		700	+
		701	+ osip_message_set_body(catlog_msg, xml_body, strlen(xml_body));
		702	+ osip_message_set_content_type(catlog_msg, "Application/MANSCDP+xml");
		703	+ eXosip_message_send_request(mSipCtx, catlog_msg);
		704	+
		705	+ eXosip_unlock(mSipCtx);
		706	+}
		707	+
		708	+int SipServer::clearClientMap(){
		709	+ std::lock_guard<std::mutex> l(m_client_map_mtx);
		710	+ for (auto iter=mClientMap.begin(); iter!=mClientMap.end(); iter++) {
		711	+ delete iter->second;
		712	+ iter->second = nullptr;
		713	+ }
		714	+ mClientMap.clear();
		715	+
		716	+ return 0;
		717	+}
		718	+
		719	+void SipServer::deleteClientByDevice(string device) {
		720	+ std::lock_guard<std::mutex> l(m_client_map_mtx);
		721	+ auto it = mClientMap.find(device);
		722	+ if (it == mClientMap.end()) {
		723	+ return ;
		724	+ }
		725	+ delete it->second;
		726	+ it->second = nullptr;
		727	+ mClientMap.erase(it);
		728	+}
		729	+
		730	+int SipServer::parse_xml(const char data, const char s_mark, bool with_s_make, const char e_mark, bool with_e_make, char dest) {
		731	+ const char* satrt = strstr( data, s_mark );
		732	+
		733	+ if(satrt != NULL) {
		734	+ const char* end = strstr(satrt, e_mark);
		735	+
		736	+ if(end != NULL){
		737	+ int s_pos = with_s_make ? 0 : strlen(s_mark);
		738	+ int e_pos = with_e_make ? strlen(e_mark) : 0;
		739	+
		740	+ strncpy( dest, satrt+s_pos, (end+e_pos) - (satrt+s_pos) );
		741	+ }
		742	+ return 0;
		743	+ }
		744	+ return -1;
		745	+
		746	+}
		747	+void SipServer::dump_request(eXosip_event_t *evtp) {
		748	+ char *s = nullptr;
		749	+ size_t len;
		750	+ osip_message_to_str(evtp->request, &s, &len);
		751	+ if (s) {
		752	+ LOG_INFO("\nprint request start\ntype={}\n{}\nprint request end\n",evtp->type,s);
		753	+ }
		754	+
		755	+ LOG_INFO("REQUEST cid:{} did: {}",evtp->cid, evtp->did);
		756	+}
		757	+void SipServer::dump_response(eXosip_event_t *evtp) {
		758	+ char *s = nullptr;
		759	+ size_t len;
		760	+ osip_message_to_str(evtp->response, &s, &len);
		761	+ if (s)
		762	+ {
		763	+ LOG_INFO("\nprint response start\ntype={}\n{}\nprint response end\n",evtp->type,s);
		764	+ }
		765	+
		766	+
		767	+ LOG_INFO("RESPONSE cid:{} did: {}",evtp->cid, evtp->did);
		768	+}
0	\ No newline at end of file	769	\ No newline at end of file

sip/SipServer.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/SipServer.h
		1	+#ifndef __SIPSERVER_H__
		2	+#define __SIPSERVER_H__
		3	+
		4	+extern "C" {
		5	+#include <osip2/osip_mt.h>
		6	+#include <eXosip2/eXosip.h>
		7	+}
		8	+
		9	+#include <map>
		10	+#include <string>
		11	+#include <thread>
		12	+#include <chrono>
		13	+#include <mutex>
		14	+#include <tuple>
		15	+
		16	+#include "./Message/CatalogParser.h"
		17	+#include "sip_header.h"
		18	+
		19	+using namespace std;
		20	+
		21	+class Client {
		22	+public:
		23	+ Client(string ip, int port, string device) :
		24	+ mIp(ip),
		25	+ mPort(port),
		26	+ mRtpPort(0),
		27	+ mDevice(device),
		28	+ mIsReg(false){
		29	+ }
		30	+ ~Client() = default;
		31	+public:
		32	+
		33	+ void setRtpPort(int rtpPort) {
		34	+ mRtpPort = rtpPort;
		35	+ }
		36	+
		37	+ void setReg(bool isReg) {
		38	+ mIsReg = isReg;
		39	+ }
		40	+ string getDevice() const{
		41	+ return mDevice;
		42	+ }
		43	+ string getIp() const{
		44	+ return mIp;
		45	+ }
		46	+ int getPort() const{
		47	+ return mPort;
		48	+ }
		49	+
		50	+ unsigned long getHeartBeat() {
		51	+ return mHeartBeatTime;
		52	+ }
		53	+
		54	+ void updateHeartBeat(unsigned long ts) {
		55	+ mHeartBeatTime = ts;
		56	+ }
		57	+
		58	+private:
		59	+ string mIp; // client ip
		60	+ int mPort; // client port
		61	+ string mDevice;// 340200000013200000024
		62	+ bool mIsReg;
		63	+ int mRtpPort;
		64	+ unsigned long mHeartBeatTime{0};
		65	+
		66	+};
		67	+
		68	+
		69	+class SipServer {
		70	+public:
		71	+ SipServer();
		72	+ ~SipServer();
		73	+
		74	+ bool Init(ServerInfo* pInfo);
		75	+
		76	+ int RequestInvite_UDP(const char* dst_channel, const char* rtpIp, int rtpPort);
		77	+
		78	+ int RequestInvite_TCP_a(const char* dst_channel, int rtpPort);
		79	+
		80	+ int ByeInvite(std::string channel_id, string ip, int rtpPort);
		81	+
		82	+ void Close();
		83	+
		84	+public:
		85	+ void event_loop();
		86	+ void timing_getcatlog();
		87	+
		88	+private:
		89	+ int init_sip_server();
		90	+ int sip_event_handle(eXosip_event_t *evtp);
		91	+
		92	+ void RequestCatalog(Client* client);
		93	+ void cacheCatalog();
		94	+
		95	+ void response_message_answer(eXosip_event_t *evtp,int code);
		96	+ void response_register(eXosip_event_t *evtp);
		97	+ void response_register_401unauthorized(eXosip_event_t *evt);
		98	+ void response_message(eXosip_event_t *evtp);
		99	+ void response_invite_ack(eXosip_event_t *evtp);
		100	+ int request_bye(eXosip_event_t* evtp);// 通知相机停止推流
		101	+ int parse_xml(const char* data, const char* s_mark, bool with_s_make, const char* e_mark, bool with_e_make, char* dest);
		102	+ void dump_request(eXosip_event_t *evtp);
		103	+ void dump_response(eXosip_event_t *evtp);
		104	+
		105	+ int clearClientMap();
		106	+ void deleteClientByDevice(string device);
		107	+
		108	+ Client* get_parent_by_id(string id);
		109	+ bool check_device_status(string id);
		110	+
		111	+ void cache_invite_callinfo(eXosip_event_t *evtp);
		112	+
		113	+private:
		114	+ bool mQuit{ false };
		115	+ eXosip_t *mSipCtx;
		116	+ ServerInfo mInfo;
		117	+
		118	+ std::map<std::string, Client *> mClientMap;// <DeviceID,SipClient>
		119	+ mutex m_client_map_mtx;
		120	+ std::map<std::string, DeviceInfo> m_device_map;
		121	+ mutex m_device_map_mtx;
		122	+
		123	+ thread* m_event_loop_thread{nullptr};
		124	+
		125	+ std::map< tuple<std::string, std::string, int>, CallInfo> m_invite_callinfo_map;
		126	+};
		127	+
		128	+
		129	+#endif //__SIPSERVER_H__

sip/Utils/HTTPDigest.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/Utils/HTTPDigest.cpp
		1	+#include "MD5.h"
		2	+#include <string.h>
		3	+#include "HTTPDigest.h"
		4	+
		5	+#ifdef _WIN32
		6	+//#define strcasecmp _stricmp
		7	+//#define strncasecmp _strnicmp
		8	+#endif
		9	+#ifdef _MSC_VER
		10	+#define strcasecmp _stricmp
		11	+#define strncasecmp _strnicmp
		12	+#endif
		13	+
		14	+void my_CvtHex(
		15	+ IN HASH Bin,
		16	+ OUT HASHHEX Hex
		17	+ )
		18	+{
		19	+ unsigned short i;
		20	+ unsigned char j;
		21	+ for (i = 0; i < HASHLEN; i++) {
		22	+ j = (Bin[i] >> 4) & 0xf;
		23	+ if (j <= 9)
		24	+ Hex[i*2] = (j + '0');
		25	+ else
		26	+ Hex[i*2] = (j + 'a' - 10);
		27	+ j = Bin[i] & 0xf;
		28	+ if (j <= 9)
		29	+ Hex[i*2+1] = (j + '0');
		30	+ else
		31	+ Hex[i*2+1] = (j + 'a' - 10);
		32	+ };
		33	+ Hex[HASHHEXLEN] = '\0';
		34	+}
		35	+
		36	+/* calculate H(A1) as per spec */
		37	+void
		38	+DigestCalcHA1 (IN const char *pszAlg,
		39	+ IN const char *pszUserName,
		40	+ IN const char *pszRealm,
		41	+ IN const char *pszPassword,
		42	+ IN const char *pszNonce,
		43	+ IN const char *pszCNonce,
		44	+ OUT HASHHEX SessionKey)
		45	+{
		46	+ MD5_CTX Md5Ctx;
		47	+ HASH HA1;
		48	+
		49	+ MD5Init (&Md5Ctx);
		50	+ MD5Update (&Md5Ctx, (unsigned char *) pszUserName, (unsigned int) strlen (pszUserName));
		51	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		52	+ MD5Update (&Md5Ctx, (unsigned char *) pszRealm, (unsigned int) strlen (pszRealm));
		53	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		54	+ MD5Update (&Md5Ctx, (unsigned char *) pszPassword, (unsigned int) strlen (pszPassword));
		55	+ MD5Final ((unsigned char *) HA1, &Md5Ctx);
		56	+ if ((pszAlg != NULL) && strcasecmp (pszAlg, "md5-sess") == 0) {
		57	+ MD5Init (&Md5Ctx);
		58	+ MD5Update (&Md5Ctx, (unsigned char *) HA1, HASHLEN);
		59	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		60	+ MD5Update (&Md5Ctx, (unsigned char *) pszNonce, (unsigned int) strlen (pszNonce));
		61	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		62	+ MD5Update (&Md5Ctx, (unsigned char *) pszCNonce, (unsigned int) strlen (pszCNonce));
		63	+ MD5Final ((unsigned char *) HA1, &Md5Ctx);
		64	+ }
		65	+ my_CvtHex (HA1, SessionKey);
		66	+}
		67	+
		68	+/* calculate request-digest/response-digest as per HTTP Digest spec */
		69	+void
		70	+DigestCalcResponse (IN HASHHEX HA1, /* H(A1) */
		71	+ IN const char pszNonce, / nonce from server */
		72	+ IN const char pszNonceCount, / 8 hex digits */
		73	+ IN const char pszCNonce, / client nonce */
		74	+ IN const char pszQop, / qop-value: "", "auth", "auth-int" */
		75	+ IN int Aka, /* Calculating AKAv1-MD5 response */
		76	+ IN const char pszMethod, / method from the request */
		77	+ IN const char pszDigestUri, / requested URL */
		78	+ IN HASHHEX HEntity, /* H(entity body) if qop="auth-int" */
		79	+ OUT HASHHEX Response
		80	+ /* request-digest or response-digest */ )
		81	+{
		82	+ MD5_CTX Md5Ctx;
		83	+ HASH HA2;
		84	+ HASH RespHash;
		85	+ HASHHEX HA2Hex;
		86	+
		87	+ /* calculate H(A2) */
		88	+ MD5Init (&Md5Ctx);
		89	+ MD5Update (&Md5Ctx, (unsigned char *) pszMethod, (unsigned int) strlen (pszMethod));
		90	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		91	+ MD5Update (&Md5Ctx, (unsigned char *) pszDigestUri, (unsigned int) strlen (pszDigestUri));
		92	+
		93	+ if (pszQop == NULL) {
		94	+ goto auth_withoutqop;
		95	+ }
		96	+ else if (0 == strcasecmp (pszQop, "auth-int")) {
		97	+ goto auth_withauth_int;
		98	+ }
		99	+ else if (0 == strcasecmp (pszQop, "auth")) {
		100	+ goto auth_withauth;
		101	+ }
		102	+
		103	+auth_withoutqop:
		104	+ MD5Final ((unsigned char *) HA2, &Md5Ctx);
		105	+ my_CvtHex (HA2, HA2Hex);
		106	+
		107	+ /* calculate response */
		108	+ MD5Init (&Md5Ctx);
		109	+ MD5Update (&Md5Ctx, (unsigned char *) HA1, HASHHEXLEN);
		110	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		111	+ MD5Update (&Md5Ctx, (unsigned char *) pszNonce, (unsigned int) strlen (pszNonce));
		112	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		113	+
		114	+ goto end;
		115	+
		116	+auth_withauth_int:
		117	+
		118	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		119	+ MD5Update (&Md5Ctx, (unsigned char *) HEntity, HASHHEXLEN);
		120	+
		121	+auth_withauth:
		122	+ MD5Final ((unsigned char *) HA2, &Md5Ctx);
		123	+ my_CvtHex (HA2, HA2Hex);
		124	+
		125	+ /* calculate response */
		126	+ MD5Init (&Md5Ctx);
		127	+ MD5Update (&Md5Ctx, (unsigned char *) HA1, HASHHEXLEN);
		128	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		129	+ MD5Update (&Md5Ctx, (unsigned char *) pszNonce, (unsigned int) strlen (pszNonce));
		130	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		131	+ if (Aka == 0) {
		132	+ MD5Update (&Md5Ctx, (unsigned char *) pszNonceCount, (unsigned int) strlen (pszNonceCount));
		133	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		134	+ MD5Update (&Md5Ctx, (unsigned char *) pszCNonce, (unsigned int) strlen (pszCNonce));
		135	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		136	+ MD5Update (&Md5Ctx, (unsigned char *) pszQop, (unsigned int) strlen (pszQop));
		137	+ MD5Update (&Md5Ctx, (unsigned char *) ":", 1);
		138	+ }
		139	+end:
		140	+ MD5Update (&Md5Ctx, (unsigned char *) HA2Hex, HASHHEXLEN);
		141	+ MD5Final ((unsigned char *) RespHash, &Md5Ctx);
		142	+ my_CvtHex (RespHash, Response);
		143	+}

sip/Utils/HTTPDigest.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/Utils/HTTPDigest.h
		1	+#define HASHLEN 16
		2	+typedef char HASH[HASHLEN];
		3	+#define HASHHEXLEN 32
		4	+typedef char HASHHEX[HASHHEXLEN+1];
		5	+#define IN
		6	+#define OUT
		7	+/* calculate H(A1) as per HTTP Digest spec */
		8	+void DigestCalcHA1 (IN const char *pszAlg,
		9	+ IN const char *pszUserName,
		10	+ IN const char *pszRealm,
		11	+ IN const char *pszPassword,
		12	+ IN const char *pszNonce,
		13	+ IN const char *pszCNonce,
		14	+ OUT HASHHEX SessionKey);
		15	+/* calculate request-digest/response-digest as per HTTP Digest spec */
		16	+void DigestCalcResponse (IN HASHHEX HA1, /* H(A1) */
		17	+ IN const char pszNonce, / nonce from server */
		18	+ IN const char pszNonceCount, / 8 hex digits */
		19	+ IN const char pszCNonce, / client nonce */
		20	+ IN const char pszQop, / qop-value: "", "auth", "auth-int" */
		21	+ IN int Aka, /* Calculating AKAv1-MD5 response */
		22	+ IN const char pszMethod, / method from the request */
		23	+ IN const char pszDigestUri, / requested URL */
		24	+ IN HASHHEX HEntity, /* H(entity body) if qop="auth-int" */
		25	+ OUT HASHHEX Response
		26	+ /* request-digest or response-digest */ );

sip/Utils/MD5.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/Utils/MD5.cpp
		1	+/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
		2	+*/
		3	+/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
		4	+rights reserved.
		5	+License to copy and use this software is granted provided that it
		6	+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
		7	+Algorithm" in all material mentioning or referencing this software
		8	+or this function.
		9	+License is also granted to make and use derivative works provided
		10	+that such works are identified as "derived from the RSA Data
		11	+Security, Inc. MD5 Message-Digest Algorithm" in all material
		12	+mentioning or referencing the derived work.
		13	+RSA Data Security, Inc. makes no representations concerning either
		14	+the merchantability of this software or the suitability of this
		15	+software for any particular purpose. It is provided "as is"
		16	+without express or implied warranty of any kind.
		17	+These notices must be retained in any copies of any part of this
		18	+documentation and/or software.
		19	+*/
		20	+#include "MD5.h"
		21	+/* Constants for MD5Transform routine.
		22	+*/
		23	+#define S11 7
		24	+#define S12 12
		25	+#define S13 17
		26	+#define S14 22
		27	+#define S21 5
		28	+#define S22 9
		29	+#define S23 14
		30	+#define S24 20
		31	+#define S31 4
		32	+#define S32 11
		33	+#define S33 16
		34	+#define S34 23
		35	+#define S41 6
		36	+#define S42 10
		37	+#define S43 15
		38	+#define S44 21
		39	+
		40	+#if 0
		41	+static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
		42	+static void Encode PROTO_LIST
		43	+ ((unsigned char , UINT4 , unsigned int));
		44	+static void Decode PROTO_LIST
		45	+ ((UINT4 , unsigned char , unsigned int));
		46	+static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));
		47	+static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
		48	+#endif
		49	+
		50	+static void MD5Transform(UINT4 [4], unsigned char [64]);
		51	+static void Encode(unsigned char , UINT4 , unsigned int);
		52	+static void Decode(UINT4 , unsigned char , unsigned int);
		53	+static void MD5_memcpy(POINTER, POINTER, unsigned int);
		54	+static void MD5_memset(POINTER, int, unsigned int);
		55	+
		56	+
		57	+static unsigned char PADDING[64] = {
		58	+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		59	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		60	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
		61	+};
		62	+/* F, G, H and I are basic MD5 functions.
		63	+*/
		64	+#define F(x, y, z) (((x) & (y)) \| ((~x) & (z)))
		65	+#define G(x, y, z) (((x) & (z)) \| ((y) & (~z)))
		66	+#define H(x, y, z) ((x) ^ (y) ^ (z))
		67	+#define I(x, y, z) ((y) ^ ((x) \| (~z)))
		68	+/* ROTATE_LEFT rotates x left n bits.
		69	+*/
		70	+#define ROTATE_LEFT(x , n) (((x) << (n)) \| ((x) >> (32-(n))))
		71	+/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
		72	+Rotation is separate from addition to prevent recomputation.
		73	+*/
		74	+#define FF(a, b, c, d, x, s, ac) { \
		75	+ (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
		76	+ (a) = ROTATE_LEFT ((a), (s));\
		77	+ (a) += (b); \
		78	+ }
		79	+#define GG(a, b, c, d, x, s, ac) { \
		80	+ (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
		81	+ (a) = ROTATE_LEFT ((a), (s)); \
		82	+ (a) += (b); \
		83	+ }
		84	+#define HH(a, b, c, d, x, s, ac) { \
		85	+ (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
		86	+ (a) = ROTATE_LEFT ((a), (s)); \
		87	+ (a) += (b); \
		88	+ }
		89	+#define II(a, b, c, d, x, s, ac) { \
		90	+ (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
		91	+ (a) = ROTATE_LEFT ((a), (s)); \
		92	+ (a) += (b); \
		93	+ }
		94	+/* MD5 initialization. Begins an MD5 operation, writing a new context.
		95	+*/
		96	+void MD5Init (MD5_CTX * context)
		97	+{
		98	+ context->count[0] = context->count[1] = 0;
		99	+ /* Load magic initialization constants.
		100	+ */
		101	+ context->state[0] = 0x67452301;
		102	+ context->state[1] = 0xefcdab89;
		103	+ context->state[2] = 0x98badcfe;
		104	+ context->state[3] = 0x10325476;
		105	+}
		106	+/* MD5 block update operation. Continues an MD5 message-digest
		107	+operation, processing another message block, and updating the
		108	+context.
		109	+*/
		110	+void MD5Update (MD5_CTX * context,unsigned char *input,unsigned int inputLen)
		111	+{
		112	+ unsigned int i, index, partLen;
		113	+ /* Compute number of bytes mod 64 */
		114	+ index = (unsigned int)((context->count[0] >> 3) & 0x3F);
		115	+ /* Update number of bits */
		116	+ if ((context->count[0] += ((UINT4)inputLen << 3))< ((UINT4)inputLen << 3))
		117	+ context->count[1]++;
		118	+ context->count[1] += ((UINT4)inputLen >> 29);
		119	+ partLen = 64 - index;
		120	+ /* Transform as many times as possible.
		121	+ */
		122	+ if (inputLen >= partLen) {
		123	+ MD5_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
		124	+ MD5Transform (context->state, context->buffer);
		125	+ for (i = partLen; i + 63 < inputLen; i += 64)
		126	+ MD5Transform (context->state, &input[i]);
		127	+ index = 0;
		128	+ }
		129	+ else
		130	+ i = 0;
		131	+ /* Buffer remaining input */
		132	+ MD5_memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],inputLen-i);
		133	+}
		134	+/* MD5 finalization. Ends an MD5 message-digest operation, writing the
		135	+the message digest and zeroizing the context.
		136	+*/
		137	+void MD5Final(unsigned char digest[16],MD5_CTX * context)
		138	+{
		139	+ unsigned char bits[8];
		140	+ unsigned int index, padLen;
		141	+ /* Save number of bits */
		142	+ Encode(bits, context->count, 8);
		143	+ /* Pad out to 56 mod 64.
		144	+ */
		145	+ index = (unsigned int)((context->count[0] >> 3) & 0x3f);
		146	+ padLen = (index < 56) ? (56 - index) : (120 - index);
		147	+ MD5Update (context, PADDING, padLen);
		148	+ /* Append length (before padding) */
		149	+ MD5Update (context, bits, 8);
		150	+ /* Store state in digest */
		151	+ Encode (digest, context->state, 16);
		152	+ /* Zeroize sensitive information.
		153	+ */
		154	+ MD5_memset ((POINTER)context, 0, sizeof (*context));
		155	+}
		156	+
		157	+
		158	+/* MD5 basic transformation. Transforms state based on block.
		159	+*/
		160	+static void MD5Transform(UINT4 state[4], unsigned char block[64])
		161	+{
		162	+ UINT4 a = state[0], b = state[1], c = state[2], d = state[3],x[16];
		163	+ Decode(x, block, 64);
		164	+ /* Round 1 */
		165	+ FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
		166	+ FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
		167	+ FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
		168	+ FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
		169	+ FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
		170	+ FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
		171	+ FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
		172	+ FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
		173	+ FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
		174	+ FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
		175	+ FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
		176	+ FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
		177	+ FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
		178	+ FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
		179	+ FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
		180	+ FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
		181	+ /* Round 2 */
		182	+ GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
		183	+ GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
		184	+ GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
		185	+ GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
		186	+ GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
		187	+ GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
		188	+ GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
		189	+ GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
		190	+ GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
		191	+ GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
		192	+ GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
		193	+
		194	+ GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
		195	+ GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
		196	+ GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
		197	+ GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
		198	+ GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
		199	+ /* Round 3 */
		200	+ HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
		201	+ HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
		202	+ HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
		203	+ HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
		204	+ HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
		205	+ HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
		206	+ HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
		207	+ HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
		208	+ HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
		209	+ HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
		210	+ HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
		211	+ HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
		212	+ HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
		213	+ HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
		214	+ HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
		215	+ HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
		216	+
		217	+ /* Round 4 */
		218	+ II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
		219	+ II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
		220	+ II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
		221	+ II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
		222	+ II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
		223	+ II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
		224	+ II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
		225	+ II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
		226	+ II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
		227	+ II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
		228	+ II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
		229	+ II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
		230	+ II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
		231	+ II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
		232	+ II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
		233	+ II (b, c, d, a, x[ 9], S44,0xeb86d391); /* 64 */
		234	+
		235	+ state[0] += a;
		236	+ state[1] += b;
		237	+ state[2] += c;
		238	+ state[3] += d;
		239	+ /* Zeroize sensitive information.
		240	+
		241	+ */
		242	+ MD5_memset((POINTER)x, 0, sizeof (x));
		243	+}
		244	+/* Encodes input (UINT4) into output (unsigned char). Assumes len is
		245	+a multiple of 4.
		246	+*/
		247	+static void Encode(unsigned char * output,UINT4 * input,unsigned int len)
		248	+{
		249	+ unsigned int i, j;
		250	+ for (i = 0, j = 0; j < len; i++, j += 4) {
		251	+ output[j] = (unsigned char)(input[i] & 0xff);
		252	+ output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
		253	+ output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
		254	+ output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
		255	+ }
		256	+}
		257	+
		258	+/* Decodes input (unsigned char) into output (UINT4). Assumes len is
		259	+a multiple of 4.
		260	+*/
		261	+static void Decode(UINT4 * output,unsigned char * input,unsigned int len)
		262	+{
		263	+ unsigned int i, j;
		264	+ for (i = 0, j = 0; j < len; i++, j += 4)
		265	+ output[i] = ((UINT4)input[j]) \| (((UINT4)input[j+1]) << 8) \|
		266	+ (((UINT4)input[j+2]) << 16) \| (((UINT4)input[j+3]) << 24);
		267	+}
		268	+
		269	+/* Note: Replace "for loop" with standard memcpy if possible.
		270	+*/
		271	+static void MD5_memcpy(POINTER output,POINTER input,unsigned int len)
		272	+{
		273	+ unsigned int i;
		274	+ for (i = 0; i < len; i++)
		275	+ output[i] = input[i];
		276	+}
		277	+/* Note: Replace "for loop" with standard memset if possible.
		278	+*/
		279	+static void MD5_memset( POINTER output, int value,unsigned int len)
		280	+{
		281	+ unsigned int i;
		282	+ for (i = 0; i < len; i++)
		283	+ ((char *)output)[i] = (char)value;
		284	+}

sip/Utils/MD5.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/Utils/MD5.h
		1	+
		2	+/* GLOBAL.H - RSAREF types and constants
		3	+*/
		4	+/* PROTOTYPES should be set to one if and only if the compiler supports
		5	+function argument prototyping.
		6	+The following makes PROTOTYPES default to 0 if it has not already been defined with C compiler flags.
		7	+*/
		8	+
		9	+
		10	+#ifndef PROTOTYPES
		11	+#define PROTOTYPES 0
		12	+#endif
		13	+/* POINTER defines a generic pointer type */
		14	+typedef unsigned char *POINTER;
		15	+/* UINT2 defines a two byte word */
		16	+typedef unsigned short int UINT2;
		17	+/* UINT4 defines a four byte word */
		18	+typedef unsigned long int UINT4;
		19	+/* PROTO_LIST is defined depending on how PROTOTYPES is defined above.
		20	+If using PROTOTYPES, then PROTO_LIST returns the list, otherwise it
		21	+returns an empty list.
		22	+*/
		23	+#if PROTOTYPES
		24	+#define PROTO_LIST(list) list
		25	+#else
		26	+#define PROTO_LIST(list) ()
		27	+#endif
		28	+
		29	+
		30	+
		31	+/* MD5.H - header file for MD5C.C
		32	+*/
		33	+/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
		34	+rights reserved.
		35	+License to copy and use this software is granted provided that it
		36	+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
		37	+Algorithm" in all material mentioning or referencing this software
		38	+or this function.
		39	+License is also granted to make and use derivative works provided
		40	+that such works are identified as "derived from the RSA Data
		41	+Security, Inc. MD5 Message-Digest Algorithm" in all material
		42	+mentioning or referencing the derived work.
		43	+RSA Data Security, Inc. makes no representations concerning either
		44	+the merchantability of this software or the suitability of this
		45	+software for any particular purpose. It is provided "as is"
		46	+without express or implied warranty of any kind.
		47	+These notices must be retained in any copies of any part of this
		48	+documentation and/or software.
		49	+*/
		50	+/* MD5 context. */
		51	+
		52	+
		53	+typedef struct {
		54	+ UINT4 state[4]; /* state (ABCD) */
		55	+ UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */
		56	+ unsigned char buffer[64]; /* input buffer */
		57	+} MD5_CTX;
		58	+
		59	+#if 0
		60	+void MD5Init PROTO_LIST ((MD5_CTX *));
		61	+void MD5Update PROTO_LIST
		62	+ ((MD5_CTX , unsigned char , unsigned int));
		63	+void MD5Final PROTO_LIST ((unsigned char [16], MD5_CTX *));
		64	+#endif
		65	+
		66	+void MD5Init(MD5_CTX *);
		67	+void MD5Update(MD5_CTX , unsigned char , unsigned int);
		68	+void MD5Final(unsigned char [16], MD5_CTX *);

sip/Utils/StringTools.hpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/Utils/StringTools.hpp
		1	+#ifndef __STRING_TOOLS_HPP__
		2	+#define __STRING_TOOLS_HPP__
		3	+
		4	+#include <string>
		5	+#include <algorithm>
		6	+#include <vector>
		7	+
		8	+using namespace std;
		9	+
		10	+namespace StringTools {
		11	+
		12	+ static bool isntspace(const char &ch) {
		13	+ return !isspace(ch);
		14	+ }
		15	+
		16	+ static std::string trim(const std::string &s) {
		17	+ std::string::const_iterator iter1 = find_if(s.begin(), s.end(), isntspace);
		18	+ std::string::const_iterator iter2 = find_if(s.rbegin(), s.rend(), isntspace).base();
		19	+
		20	+ return iter1 < iter2 ? string(iter1, iter2) : std::string("");
		21	+ }
		22	+
		23	+ static vector<string> split(const string &origin,const string &sep){
		24	+ size_t found = origin.find(sep);
		25	+ size_t s = 0;
		26	+ std::vector<string> vec;
		27	+ while (found != string::npos)
		28	+ {
		29	+ string kv = origin.substr(s,found - s);
		30	+ vec.push_back(trim(kv));
		31	+ s = found + 1;
		32	+ found = origin.find(sep,s);
		33	+ }
		34	+ vec.push_back(origin.substr(s,origin.length() - s));
		35	+ return vec;
		36	+ }
		37	+
		38	+ static string to_lower(string origin) {
		39	+ string str_lower = trim(origin);
		40	+ transform(str_lower.begin(), str_lower.end(), str_lower.begin(),::tolower);
		41	+ return str_lower;
		42	+ }
		43	+}
		44	+
		45	+#endif
0	\ No newline at end of file	46	\ No newline at end of file

sip/Utils/Utools.hpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/Utils/Utools.hpp
		1	+#ifndef __UTOOLS_HPP__
		2	+#define __UTOOLS_HPP__
		3	+
		4	+#include <chrono>
		5	+
		6	+using namespace std;
		7	+
		8	+namespace Utools{
		9	+
		10	+ static long get_cur_time_ms() {
		11	+ chrono::time_point<chrono::system_clock, chrono::milliseconds> tpMicro
		12	+ = chrono::time_point_cast<chrono::milliseconds>(chrono::system_clock::now());
		13	+ return tpMicro.time_since_epoch().count();
		14	+ }
		15	+
		16	+}
		17	+
		18	+#endif
0	\ No newline at end of file	19	\ No newline at end of file

sip/Utils/logger.hpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/Utils/logger.hpp
		1	+/*
		2	+ * @Author: yangzilong
		3	+ * @Date: 2021-12-21 11:07:11
		4	+ * @Last Modified by: yangzilong
		5	+ * @Email: yangzilong@objecteye.com
		6	+ * @Description:
		7	+ */
		8	+
		9	+#ifndef __LOGGER_HPP__
		10	+#define __LOGGER_HPP__
		11	+
		12	+
		13	+#include <spdlog/spdlog.h>
		14	+#include <spdlog/common.h>
		15	+#include <spdlog/details/file_helper.h>
		16	+#include <spdlog/details/null_mutex.h>
		17	+#include <spdlog/fmt/fmt.h>
		18	+#include <spdlog/sinks/base_sink.h>
		19	+#include <spdlog/details/os.h>
		20	+#include <spdlog/details/circular_q.h>
		21	+#include <spdlog/details/synchronous_factory.h>
		22	+
		23	+#include <set>
		24	+#include <chrono>
		25	+#include <cstdio>
		26	+#include <ctime>
		27	+#include <mutex>
		28	+#include <string>
		29	+#include <memory>
		30	+#include <vector>
		31	+
		32	+
		33	+
		34	+#define LOG_TRACE_WITH_LOGGER(logger, ...) {SPDLOG_LOGGER_TRACE(logger, __VA_ARGS__);}
		35	+#define LOG_DEBUG_WITH_LOGGER(logger, ...) {SPDLOG_LOGGER_DEBUG(logger, __VA_ARGS__);}
		36	+#define LOG_WARN_WITH_LOGGER(logger, ...) {SPDLOG_LOGGER_WARN(logger, __VA_ARGS__);}
		37	+#define LOG_ERROR_WITH_LOGGER(logger, ...) {SPDLOG_LOGGER_ERROR(logger, __VA_ARGS__);}
		38	+#define LOG_INFO_WITH_LOGGER(logger, ...) {SPDLOG_LOGGER_INFO(logger, __VA_ARGS__);}
		39	+#define LOG_CRITICAL_WITH_LOGGER(logger, ...) {SPDLOG_LOGGER_CRITICAL(logger, __VA_ARGS__);}
		40	+
		41	+
		42	+#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
		43	+
		44	+// use fmt lib, e.g. LOG_WARN("warn log, {1}, {1}, {2}", 1, 2);
		45	+#define LOG_TRACE(msg, ...) spdlog::log({__FILENAME__, __LINE__, __FUNCTION__}, spdlog::level::trace, msg, ##__VA_ARGS__)
		46	+#define LOG_DEBUG(msg, ...) spdlog::log({__FILENAME__, __LINE__, __FUNCTION__}, spdlog::level::debug, msg, ##__VA_ARGS__)
		47	+#define LOG_INFO(msg,...) spdlog::log({__FILENAME__, __LINE__, __FUNCTION__}, spdlog::level::info, msg, ##__VA_ARGS__)
		48	+#define LOG_WARN(msg,...) spdlog::log({__FILENAME__, __LINE__, __FUNCTION__}, spdlog::level::warn, msg, ##__VA_ARGS__)
		49	+#define LOG_ERROR(msg,...) spdlog::log({__FILENAME__, __LINE__, __FUNCTION__}, spdlog::level::err, msg, ##__VA_ARGS__)
		50	+#define LOG_FATAL(msg,...) spdlog::log({__FILENAME__, __LINE__, __FUNCTION__}, spdlog::level::critical, msg, ##__VA_ARGS__)
		51	+
		52	+
		53	+
		54	+namespace spdlog
		55	+{
		56	+ namespace sinks
		57	+ {
		58	+ template<typename Mutex>
		59	+ class easy_file_sink final : public base_sink<Mutex>
		60	+ {
		61	+ public:
		62	+ easy_file_sink(filename_t base_filename, size_t max_size, size_t max_keep_days = 0)
		63	+ : base_filename_(std::move(base_filename))
		64	+ , max_size_(max_size)
		65	+ , max_keep_days_(max_keep_days)
		66	+ {
		67	+ auto now = log_clock::now();
		68	+ auto filename = gen_filename_by_daliy(base_filename_, now_tm(now));
		69	+
		70	+ file_helper_.open(filename, false);
		71	+ current_size_ = file_helper_.size();
		72	+ rotation_tp_ = next_rotation_tp_();
		73	+
		74	+ if (max_keep_days_ > 0)
		75	+ {
		76	+ filespath_q_.push_back(std::move(std::set<filename_t>()));
		77	+ filespath_q_[filespath_q_.size() - 1].insert(filename);
		78	+ }
		79	+ }
		80	+
		81	+ filename_t filename()
		82	+ {
		83	+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
		84	+ return file_helper_.filename();
		85	+ }
		86	+
		87	+ protected:
		88	+ void sink_it_(const details::log_msg &msg) override
		89	+ {
		90	+ memory_buf_t formatted;
		91	+ base_sink<Mutex>::formatter_->format(msg, formatted);
		92	+ current_size_ += formatted.size();
		93	+
		94	+ auto time = msg.time;
		95	+ if (time >= rotation_tp_)
		96	+ {
		97	+ file_helper_.close();
		98	+ auto filename = gen_filename_by_daliy(base_filename_, now_tm(time));
		99	+ file_helper_.open(filename, false);
		100	+ current_size_ = file_helper_.size();
		101	+ rotation_tp_ = next_rotation_tp_();
		102	+
		103	+ {
		104	+ filespath_q_.push_back(std::move(std::set<filename_t>()));
		105	+ filespath_q_[filespath_q_.size() - 1].emplace(filename);
		106	+ }
		107	+
		108	+ // Do the cleaning only at the end because it might throw on failure.
		109	+ if (max_keep_days_ > 0 && filespath_q_.size() > max_keep_days_)
		110	+ delete_old_();
		111	+ }
		112	+ else if (current_size_ >= max_size_)
		113	+ {
		114	+ file_helper_.close();
		115	+ auto src_name = gen_filename_by_daliy(base_filename_, now_tm(time));
		116	+ auto target_name = gen_filename_by_filesize(base_filename_, now_tm(time), filespath_q_[filespath_q_.size() - 1].size());
		117	+
		118	+ // rename file if failed then us `target_name` as src_name.
		119	+ if (!rename_file_(src_name, target_name))
		120	+ {
		121	+ details::os::sleep_for_millis(200);
		122	+ if (!rename_file_(src_name, target_name))
		123	+ {
		124	+ fprintf(stderr, "%s:%d rename %s to %s failed\n", __FILENAME__, __LINE__, src_name.c_str(), target_name.c_str());
		125	+ src_name = target_name;
		126	+ }
		127	+ }
		128	+
		129	+ filespath_q_[filespath_q_.size() - 1].emplace(src_name);
		130	+ if (src_name != target_name)
		131	+ filespath_q_[filespath_q_.size() - 1].emplace(target_name);
		132	+
		133	+ file_helper_.open(src_name, false);
		134	+ current_size_ = file_helper_.size();
		135	+ rotation_tp_ = next_rotation_tp_();
		136	+ }
		137	+
		138	+ file_helper_.write(formatted);
		139	+
		140	+
		141	+ }
		142	+
		143	+ void flush_() override
		144	+ {
		145	+ file_helper_.flush();
		146	+ }
		147	+
		148	+ private:
		149	+
		150	+ tm now_tm(log_clock::time_point tp)
		151	+ {
		152	+ time_t tnow = log_clock::to_time_t(tp);
		153	+ return spdlog::details::os::localtime(tnow);
		154	+ }
		155	+
		156	+ /**
		157	+ * @brief Get next day tm.
		158	+ *
		159	+ * @return log_clock::time_point
		160	+ */
		161	+ log_clock::time_point next_rotation_tp_()
		162	+ {
		163	+ auto now = log_clock::now();
		164	+ tm date = now_tm(now);
		165	+ date.tm_hour = 0;
		166	+ date.tm_min = 0;
		167	+ date.tm_sec = 0;
		168	+ auto rotation_time = log_clock::from_time_t(std::mktime(&date));
		169	+ if (rotation_time > now)
		170	+ return rotation_time;
		171	+ return {rotation_time + std::chrono::hours(24)};
		172	+ }
		173	+
		174	+ // Delete the file N rotations ago.
		175	+ // Throw spdlog_ex on failure to delete the old file.
		176	+ void delete_old_()
		177	+ {
		178	+ for (auto iter = filespath_q_.begin(); iter != filespath_q_.end();)
		179	+ {
		180	+ if (filespath_q_.size() <= max_keep_days_)
		181	+ break;
		182	+
		183	+ for (auto it = iter->begin(); it != iter->end(); ++it)
		184	+ {
		185	+ bool ok = details::os::remove_if_exists(*it) == 0;
		186	+ if (!ok)
		187	+ throw_spdlog_ex("Failed removing daily file " + details::os::filename_to_str(*it), errno);
		188	+ }
		189	+ filespath_q_.erase(iter);
		190	+ }
		191	+ }
		192	+
		193	+ /* */
		194	+ static filename_t gen_filename_by_daliy(const filename_t &filename, const tm &now_tm)
		195	+ {
		196	+ filename_t basename, ext;
		197	+ std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
		198	+ return fmt::format(SPDLOG_FILENAME_T("{}_{:04d}_{:02d}_{:02d}{}"),
		199	+ basename,
		200	+ now_tm.tm_year + 1900,
		201	+ now_tm.tm_mon + 1,
		202	+ now_tm.tm_mday,
		203	+ ext);
		204	+ }
		205	+
		206	+ //
		207	+ static filename_t gen_filename_by_filesize(const filename_t &filename, const tm &now_tm, const int &idx)
		208	+ {
		209	+ filename_t basename, ext;
		210	+ std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
		211	+ return fmt::format(SPDLOG_FILENAME_T("{}_{:04d}_{:02d}_{:02d}_{:02d}{:02d}{:02d}.{:d}{}"),
		212	+ basename,
		213	+ now_tm.tm_year + 1900,
		214	+ now_tm.tm_mon + 1,
		215	+ now_tm.tm_mday,
		216	+ now_tm.tm_hour,
		217	+ now_tm.tm_min,
		218	+ now_tm.tm_sec,
		219	+ idx,
		220	+ ext);
		221	+ }
		222	+
		223	+ static bool rename_file_(const filename_t &src_filename, const filename_t &target_filename)
		224	+ {
		225	+ (void)details::os::remove(target_filename);
		226	+ return details::os::rename(src_filename, target_filename) == 0;
		227	+ }
		228	+
		229	+ filename_t base_filename_;
		230	+ log_clock::time_point rotation_tp_;
		231	+ details::file_helper file_helper_;
		232	+ std::size_t max_size_;
		233	+ std::size_t max_keep_days_;
		234	+ std::size_t current_size_;
		235	+ // std::vector<<std::set<filename_t>> filespath_q_;
		236	+ std::vector<std::set<filename_t>> filespath_q_;
		237	+ };
		238	+
		239	+ using easy_file_sink_mt = easy_file_sink<std::mutex>;
		240	+ using easy_file_sink_st = easy_file_sink<details::null_mutex>;
		241	+
		242	+ } // namespace sinks
		243	+
		244	+ template<typename Factory = spdlog::synchronous_factory>
		245	+ inline std::shared_ptr<logger> easy_logger_mt(
		246	+ const std::string &logger_name, const filename_t &filename, size_t max_size, size_t max_keep_days = -1)
		247	+ {
		248	+ return Factory::template create<sinks::easy_file_sink_mt>(logger_name, filename, max_size, max_keep_days);
		249	+ }
		250	+
		251	+ template<typename Factory = spdlog::synchronous_factory>
		252	+ inline std::shared_ptr<logger> easy_logger_st(
		253	+ const std::string &logger_name, const filename_t &filename, size_t max_size, size_t max_keep_days = -1)
		254	+ {
		255	+ return Factory::template create<sinks::easy_file_sink_st>(logger_name, filename, max_size, max_keep_days);
		256	+ }
		257	+
		258	+} // namespace spdlog
		259	+
		260	+
		261	+enum class LogLevel
		262	+{
		263	+ SPD_LOG_CLOSE = -1,
		264	+ SPD_LOG_TRACE = 0,
		265	+ SPD_LOG_DEBUG = 1,
		266	+ SPD_LOG_INFO = 2,
		267	+ SPD_LOG_WARN = 3,
		268	+ SPD_LOG_ERROR = 4,
		269	+ SPD_LOG_FATAL = 5,
		270	+};
		271	+
		272	+
		273	+class LoggerGenerator
		274	+{
		275	+public:
		276	+ static LoggerGenerator* get_instance()
		277	+ {
		278	+ static LoggerGenerator logger;
		279	+ return &logger;
		280	+ }
		281	+
		282	+ void destory(LoggerGenerator *ptr)
		283	+ {
		284	+ if (ptr != nullptr)
		285	+ {
		286	+ delete ptr;
		287	+ ptr = nullptr;
		288	+ }
		289	+ }
		290	+
		291	+ std::shared_ptr<spdlog::logger> gen_logger(const LogLevel &level, const std::string &logger_name,
		292	+ const std::string &file_path, size_t max_file_size, size_t max_keep_days)
		293	+ {
		294	+ spdlog::level::level_enum spd_level;
		295	+ if (LogLevel::SPD_LOG_TRACE == level)
		296	+ spd_level = spdlog::level::trace;
		297	+ else if (LogLevel::SPD_LOG_DEBUG == level)
		298	+ spd_level = spdlog::level::debug;
		299	+ else if (LogLevel::SPD_LOG_INFO == level)
		300	+ spd_level = spdlog::level::info;
		301	+ else if (LogLevel::SPD_LOG_WARN == level)
		302	+ spd_level = spdlog::level::warn;
		303	+ else if (LogLevel::SPD_LOG_ERROR == level)
		304	+ spd_level = spdlog::level::err;
		305	+ else if (LogLevel::SPD_LOG_FATAL == level)
		306	+ spd_level = spdlog::level::critical;
		307	+ else if (LogLevel::SPD_LOG_CLOSE == level)
		308	+ spd_level = spdlog::level::off;
		309	+
		310	+ auto sink_ptr = std::make_shared<spdlog::sinks::easy_file_sink_mt>(file_path, max_file_size, max_keep_days);
		311	+ auto logger = std::make_shared<spdlog::logger>(logger_name, sink_ptr);
		312	+ logger->set_level(spd_level);
		313	+ logger->set_pattern("%s(%#): [%L %D %T.%e %P %t %!] %v");
		314	+
		315	+ return logger;
		316	+ }
		317	+
		318	+ void set_default_logger(const LogLevel &level, const std::string &logger_name,
		319	+ const std::string &file_name, size_t max_file_size, size_t max_keep_days)
		320	+ {
		321	+
		322	+ auto logger = gen_logger(level, logger_name, file_name, max_file_size, max_keep_days);
		323	+ spdlog::set_default_logger(logger);
		324	+ spdlog::set_level(logger->level());
		325	+ spdlog::set_pattern("%s(%#): [%L %D %T.%e %P %t %!] %v");
		326	+
		327	+ spdlog::flush_on(spdlog::level::trace);
		328	+ spdlog::flush_every(std::chrono::seconds(1));
		329	+ }
		330	+
		331	+};
		332	+
		333	+
		334	+static void set_default_logger(const LogLevel &level, const std::string &logger_name,
		335	+ const std::string &file_path, size_t max_file_size, size_t max_keep_days)
		336	+{
		337	+ static LoggerGenerator loggerGenerator;
		338	+ loggerGenerator.set_default_logger(level, logger_name, file_path, max_file_size, max_keep_days);
		339	+}
		340	+
		341	+
		342	+static std::shared_ptr<spdlog::logger> get_simple_logger(const LogLevel &level, const std::string &logger_name,
		343	+ const std::string &file_path, size_t max_file_size, size_t max_keep_days)
		344	+{
		345	+ static LoggerGenerator loggerGenerator;
		346	+ return loggerGenerator.gen_logger(level, logger_name, file_path, max_file_size, max_keep_days);
		347	+}
		348	+
		349	+
		350	+#endif // __LOGGER_HPP__
0	\ No newline at end of file	351	\ No newline at end of file

sip/WebSocketServer.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/WebSocketServer.cpp
		1	+#include <iostream>
		2	+
		3	+#include "WebSocketServer.h"
		4	+#include "./Utils/StringTools.hpp"
		5	+#include "ConfigParser.hpp"
		6	+#include "./Utils/logger.hpp"
		7	+
		8	+using websocketpp::lib::placeholders::_1;
		9	+using websocketpp::lib::placeholders::_2;
		10	+using websocketpp::lib::bind;
		11	+
		12	+
		13	+WebSocketServer::WebSocketServer(/* args */)
		14	+{
		15	+}
		16	+
		17	+WebSocketServer::~WebSocketServer()
		18	+{
		19	+}
		20	+
		21	+int WebSocketServer::parse_invite(vector<string>& vec_msg, std::string ip) {
		22	+ string net_type = "";
		23	+ if (StringTools::to_lower(vec_msg[1]) == "udp") {
		24	+ net_type = "udp";
		25	+ } else if (StringTools::to_lower(vec_msg[1]) == "tcp") {
		26	+ net_type = "tcp";
		27	+ }
		28	+ std::cout << "net type: " << vec_msg[1] << std::endl;
		29	+
		30	+ std::cout << "invite " << vec_msg[2] << ":" << vec_msg[3] << std::endl;
		31	+ int ret = -100;
		32	+ if ("udp" == net_type) {
		33	+ ret = sip_server.RequestInvite_UDP(vec_msg[2].c_str(), ip.c_str(), atoi(vec_msg[3].c_str()));
		34	+ // ret = sip_server.RequestInvite_UDP(vec_data[0].c_str(), "176.10.0.3", 30026);
		35	+ } else if ("tcp" == net_type)
		36	+ {
		37	+ /* code */
		38	+ }
		39	+
		40	+ return ret;
		41	+}
		42	+
		43	+string WebSocketServer::get_ip_from_hdl(websocketpp::connection_hdl hdl) {
		44	+ server::connection_ptr con = ws_server.get_con_from_hdl(hdl);
		45	+ // 获取客户端IP地址
		46	+ auto addr = con->get_socket().remote_endpoint().address().to_string();
		47	+ std::string ip = addr.substr(addr.find_last_of(":")+1);
		48	+ std::cout << "ip:" << ip << endl;
		49	+ return ip;
		50	+}
		51	+
		52	+int WebSocketServer::msg_parser(websocketpp::connection_hdl hdl, string msg) {
		53	+ vector<string> vec_msg = StringTools::split(msg, "\|");
		54	+ if (vec_msg.size() <= 0) {
		55	+ return -1;
		56	+ }
		57	+
		58	+ string ip = get_ip_from_hdl(hdl);
		59	+
		60	+ int ret = -100;
		61	+ if ( StringTools::to_lower(vec_msg[0]) == "invite") {
		62	+ ret = parse_invite(vec_msg, ip);
		63	+ } else if ( StringTools::to_lower(vec_msg[0]) == "bye") {
		64	+ if (StringTools::to_lower(vec_msg[1]) == "invite") {
		65	+ std::cout << "bye invite: " << vec_msg[2] << std::endl;
		66	+ ret = sip_server.ByeInvite(vec_msg[2], ip, atoi(vec_msg[3].c_str()));
		67	+ }
		68	+ } else {
		69	+ std::cout << "on_message called with hdl: " << hdl.lock().get()
		70	+ << " and message: " << msg
		71	+ << std::endl;
		72	+ }
		73	+
		74	+ return ret;
		75	+}
		76	+
		77	+// Define a callback to handle incoming messages
		78	+void WebSocketServer::on_message(websocketpp::connection_hdl hdl, message_ptr msg) {
		79	+
		80	+ if (msg->get_payload() == "stop-listening") {
		81	+ ws_server.stop_listening();
		82	+ return;
		83	+ }
		84	+
		85	+ try {
		86	+ int ret = msg_parser(hdl,msg->get_payload());
		87	+ // 返回执行结果
		88	+ ws_server.send(hdl, to_string(ret), websocketpp::frame::opcode::text);
		89	+ } catch (websocketpp::exception const & e) {
		90	+ std::cout << "Echo failed because: " << "(" << e.what() << ")" << std::endl;
		91	+ ws_server.send(hdl, to_string(-101), websocketpp::frame::opcode::text);
		92	+ }
		93	+}
		94	+
		95	+void WebSocketServer::on_open(websocketpp::connection_hdl hdl)
		96	+{
		97	+ // std::string msg = "hello";
		98	+ // c.send(hdl, msg, websocketpp::frame::opcode::text);
		99	+ // c.get_alog().write(websocketpp::log::alevel::app, "Tx: " + msg);
		100	+ std::cout << "连接sip服务器成功！" << std::endl;
		101	+}
		102	+
		103	+void WebSocketServer::on_fail(websocketpp::connection_hdl h){
		104	+ std::cout << "连接sip服务器失败！" << std::endl;
		105	+}
		106	+
		107	+void WebSocketServer::on_close(websocketpp::connection_hdl h){
		108	+ std::cout << "on_close" << std::endl;
		109	+}
		110	+
		111	+
		112	+void WebSocketServer::start() {
		113	+ ConfigParser* pConfig = ConfigParser::getInstance();
		114	+ if (!pConfig->init())
		115	+ {
		116	+ LOG_ERROR("get config failed!");
		117	+ return;
		118	+ }
		119	+
		120	+ ServerInfo info = pConfig->getServerCfg();
		121	+
		122	+ sip_server.Init(&info);
		123	+
		124	+ try {
		125	+ // Set logging settings
		126	+ ws_server.set_access_channels(websocketpp::log::alevel::all);
		127	+ ws_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
		128	+
		129	+ // Initialize Asio
		130	+ ws_server.init_asio();
		131	+
		132	+ // Register our message handler
		133	+ ws_server.set_message_handler(bind(&WebSocketServer::on_message,this,::_1,::_2));
		134	+ ws_server.set_open_handler(bind(&WebSocketServer::on_open, this, _1));
		135	+ ws_server.set_fail_handler(bind(&WebSocketServer::on_fail, this, _1));
		136	+ ws_server.set_close_handler(bind(&WebSocketServer::on_close, this, _1));
		137	+
		138	+ // Listen on port 9002
		139	+ int port = info.getWsPort();
		140	+ std::cout << "websocket server listen:" << port << std::endl;
		141	+ ws_server.listen(port);
		142	+
		143	+ // Start the server accept loop
		144	+ ws_server.start_accept();
		145	+
		146	+ // Start the ASIO io_service run loop
		147	+ ws_server.run();
		148	+ } catch (websocketpp::exception const & e) {
		149	+ std::cout << e.what() << std::endl;
		150	+ } catch (...) {
		151	+ std::cout << "other exception" << std::endl;
		152	+ }
		153	+}

sip/WebSocketServer.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/WebSocketServer.h
		1	+#include <websocketpp/config/asio_no_tls.hpp>
		2	+#include <websocketpp/server.hpp>
		3	+
		4	+#include "SipServer.h"
		5	+
		6	+typedef websocketpp::server<websocketpp::config::asio> server;
		7	+
		8	+// pull out the type of messages sent by our config
		9	+typedef server::message_ptr message_ptr;
		10	+
		11	+
		12	+class WebSocketServer
		13	+{
		14	+public:
		15	+ WebSocketServer(/* args */);
		16	+ ~WebSocketServer();
		17	+
		18	+ // Define a callback to handle incoming messages
		19	+ void on_message(websocketpp::connection_hdl hdl, message_ptr msg) ;
		20	+
		21	+ void on_open(websocketpp::connection_hdl hdl);
		22	+ void on_close(websocketpp::connection_hdl hdl);
		23	+ void on_fail(websocketpp::connection_hdl hdl);
		24	+
		25	+ void start();
		26	+
		27	+private:
		28	+ int msg_parser(websocketpp::connection_hdl hdl, string msg);
		29	+ int parse_invite(vector<string>& vec_msg, std::string ip);
		30	+
		31	+ string get_ip_from_hdl(websocketpp::connection_hdl hdl);
		32	+
		33	+private:
		34	+ server ws_server;
		35	+ SipServer sip_server;
		36	+};
0	\ No newline at end of file	37	\ No newline at end of file

sip/main.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/main.cpp
		1	+
		2	+#include "WebSocketServer.h"
		3	+
		4	+
		5	+int main(int argc, char *argv[]) {
		6	+
		7	+ // if (argc <= 1)
		8	+ // {
		9	+ // printf("请输入待获取的摄像头的视频通道编码ID。");
		10	+ // return -1;
		11	+ // }
		12	+
		13	+ WebSocketServer server;
		14	+ server.start();
		15	+
		16	+ // const char* sipid = "34020000001310000001";
		17	+ // const char* sipid = argv[1];
		18	+ // char oper = 'g';
		19	+ // while (oper != 'q') {
		20	+ // oper = getchar();
		21	+ // switch (oper)
		22	+ // {
		23	+ // case 'g':
		24	+ // break;
		25	+ // case 'i':
		26	+ // {
		27	+ // pServer->RequestInvite_UDP(sipid, rtp_port);
		28	+ // }
		29	+ // break;
		30	+ // case 'b':
		31	+ // break;
		32	+ // default:
		33	+ // break;
		34	+ // }
		35	+ // }
		36	+
		37	+ return 0;
		38	+}
0	\ No newline at end of file	39	\ No newline at end of file

sip/sip_header.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/sip_header.h
		1	+#ifndef __SIP_HEADER_H__
		2	+#define __SIP_HEADER_H__
		3	+
		4	+#include <string>
		5	+
		6	+using namespace std;
		7	+
		8	+enum EEventType
		9	+{
		10	+ EVENT_ON = 0, // ��
		11	+ EVENT_OFF, // ��
		12	+ EVENT_VLOST, // ��Ƶ��ʧ
		13	+ EVENT_DEFECT, // ��
		14	+ EVENT_ADD, // ��
		15	+ EVENT_DEL, // ɾ��
		16	+ EVENT_UPDATE, // ��
		17	+
		18	+ EVENT_UNKNOW,
		19	+};
		20	+
		21	+struct DeviceInfo
		22	+{
		23	+ EEventType event;
		24	+ std::string id;
		25	+ std::string name;
		26	+ std::string manufacturer;
		27	+ std::string model;
		28	+ std::string owner;
		29	+ std::string civil;
		30	+ std::string block;
		31	+ std::string address;
		32	+ std::string safetyway;
		33	+ std::string registerway;
		34	+ std::string certnum;
		35	+ std::string certifiable;
		36	+ std::string errcode;
		37	+ std::string secrecy;
		38	+ std::string parental;
		39	+ std::string parentid;
		40	+ std::string endtime;
		41	+ std::string ip;
		42	+ std::string port;
		43	+ std::string password;
		44	+ std::string status;
		45	+ std::string longitude;
		46	+ std::string latitude;
		47	+ std::string ptz;
		48	+ std::string position;
		49	+ std::string room;
		50	+ std::string use;
		51	+ std::string supplylight;
		52	+ std::string direction;
		53	+ std::string resolution;
		54	+ std::string businessgroup;
		55	+};
		56	+
		57	+class ServerInfo {
		58	+public:
		59	+ ServerInfo() {}
		60	+
		61	+ ServerInfo(string ua,string nonce, string ip, int port,
		62	+ string sipId, string sipRealm, string sipPass, int sipTimeout, int sipExpiry, int minRtpPort, int maxRtpPort, int ws_port):
		63	+ mUa(ua),mNonce(nonce),mIp(ip),mPort(port),mSipId(sipId),
		64	+ mSipRealm(sipRealm),mSipPass(sipPass),mSipTimeout(sipTimeout),
		65	+ mSipExpiry(sipExpiry),mMinRtpPort(minRtpPort),mMaxRtpPort(maxRtpPort),mWsPort(ws_port){}
		66	+
		67	+ ~ServerInfo() = default;
		68	+public:
		69	+ string getUa() const{
		70	+ return mUa;
		71	+ }
		72	+ void setUa(string ua) {
		73	+ mUa = ua;
		74	+ }
		75	+ string getNonce() const{
		76	+ return mNonce;
		77	+ }
		78	+ void setNonce(string nonce) {
		79	+ mNonce = nonce;
		80	+ }
		81	+ string getIp() const{
		82	+ return mIp;
		83	+ }
		84	+ void setIp(string s) {
		85	+ mIp = s;
		86	+ }
		87	+ int getPort() const {
		88	+ return mPort;
		89	+ }
		90	+ void setPort(int i) {
		91	+ mPort = i;
		92	+ }
		93	+
		94	+ string getSipId() const{
		95	+ return mSipId;
		96	+ }
		97	+ void setSipId(string s) {
		98	+ mSipId = s;
		99	+ }
		100	+ string getSipRealm() const{
		101	+ return mSipRealm;
		102	+ }
		103	+ void setSipRealm(string s) {
		104	+ mSipRealm = s;
		105	+ }
		106	+ string getSipPass() const{
		107	+ return mSipPass;
		108	+ }
		109	+ void setSipPass(string s) {
		110	+ mSipPass = s;
		111	+ }
		112	+ int getTimeout() const {
		113	+ return mSipTimeout;
		114	+ }
		115	+ void setTimeout(int i) {
		116	+ mSipTimeout = i;
		117	+ }
		118	+ int getExpiry() const {
		119	+ return mSipExpiry;
		120	+ }
		121	+ void setExpiry(int i) {
		122	+ mSipExpiry = i;
		123	+ }
		124	+ int getMinRtpPort() const {
		125	+ return mMinRtpPort;
		126	+ }
		127	+ void setMinRtpPort(int i) {
		128	+ mMinRtpPort = i;
		129	+ }
		130	+ int getMaxRtpPort() const {
		131	+ return mMaxRtpPort;
		132	+ }
		133	+ void setMaxRtpPort(int i) {
		134	+ mMaxRtpPort = i;
		135	+ }
		136	+ int getWsPort() const {
		137	+ return mWsPort;
		138	+ }
		139	+ void setWsPort(int i) {
		140	+ mWsPort = i;
		141	+ }
		142	+
		143	+private:
		144	+ string mUa;
		145	+ string mNonce;//SIP服务随机数值
		146	+ string mIp;//SIP服务IP
		147	+ int mPort{0};//SIP服务端口
		148	+ string mSipId; //SIP服务器ID
		149	+ string mSipRealm;//SIP服务器域
		150	+ string mSipPass;//SIP password
		151	+ int mSipTimeout; //SIP timeout
		152	+ int mSipExpiry;// SIP到期
		153	+ int mMinRtpPort;
		154	+ int mMaxRtpPort;
		155	+ int mWsPort;
		156	+};
		157	+
		158	+struct CallInfo {
		159	+ int cid{-1};
		160	+ int did{-1};
		161	+};
		162	+
		163	+#endif //__SIP_HEADER_H__
0	\ No newline at end of file	164	\ No newline at end of file

sip/tinyxml2/tinyxml2.cpp 0 → 100644

View file @c887a0f

		1	+++ a/sip/tinyxml2/tinyxml2.cpp
		1	+/*
		2	+Original code by Lee Thomason (www.grinninglizard.com)
		3	+
		4	+This software is provided 'as-is', without any express or implied
		5	+warranty. In no event will the authors be held liable for any
		6	+damages arising from the use of this software.
		7	+
		8	+Permission is granted to anyone to use this software for any
		9	+purpose, including commercial applications, and to alter it and
		10	+redistribute it freely, subject to the following restrictions:
		11	+
		12	+1. The origin of this software must not be misrepresented; you must
		13	+not claim that you wrote the original software. If you use this
		14	+software in a product, an acknowledgment in the product documentation
		15	+would be appreciated but is not required.
		16	+
		17	+2. Altered source versions must be plainly marked as such, and
		18	+must not be misrepresented as being the original software.
		19	+
		20	+3. This notice may not be removed or altered from any source
		21	+distribution.
		22	+*/
		23	+
		24	+#include "tinyxml2.h"
		25	+
		26	+#include <new> // yes, this one new style header, is in the Android SDK.
		27	+#if defined(ANDROID_NDK) \|\| defined(__BORLANDC__) \|\| defined(__QNXNTO__)
		28	+# include <stddef.h>
		29	+# include <stdarg.h>
		30	+#else
		31	+# include <cstddef>
		32	+# include <cstdarg>
		33	+#endif
		34	+
		35	+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
		36	+ // Microsoft Visual Studio, version 2005 and higher. Not WinCE.
		37	+ /*int _snprintf_s(
		38	+ char *buffer,
		39	+ size_t sizeOfBuffer,
		40	+ size_t count,
		41	+ const char *format [,
		42	+ argument] ...
		43	+ );*/
		44	+ static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
		45	+ {
		46	+ va_list va;
		47	+ va_start( va, format );
		48	+ int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
		49	+ va_end( va );
		50	+ return result;
		51	+ }
		52	+
		53	+ static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )
		54	+ {
		55	+ int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
		56	+ return result;
		57	+ }
		58	+
		59	+ #define TIXML_VSCPRINTF _vscprintf
		60	+ #define TIXML_SSCANF sscanf_s
		61	+#elif defined _MSC_VER
		62	+ // Microsoft Visual Studio 2003 and earlier or WinCE
		63	+ #define TIXML_SNPRINTF _snprintf
		64	+ #define TIXML_VSNPRINTF _vsnprintf
		65	+ #define TIXML_SSCANF sscanf
		66	+ #if (_MSC_VER < 1400 ) && (!defined WINCE)
		67	+ // Microsoft Visual Studio 2003 and not WinCE.
		68	+ #define TIXML_VSCPRINTF _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.
		69	+ #else
		70	+ // Microsoft Visual Studio 2003 and earlier or WinCE.
		71	+ static inline int TIXML_VSCPRINTF( const char* format, va_list va )
		72	+ {
		73	+ int len = 512;
		74	+ for (;;) {
		75	+ len = len*2;
		76	+ char* str = new char[len]();
		77	+ const int required = _vsnprintf(str, len, format, va);
		78	+ delete[] str;
		79	+ if ( required != -1 ) {
		80	+ TIXMLASSERT( required >= 0 );
		81	+ len = required;
		82	+ break;
		83	+ }
		84	+ }
		85	+ TIXMLASSERT( len >= 0 );
		86	+ return len;
		87	+ }
		88	+ #endif
		89	+#else
		90	+ // GCC version 3 and higher
		91	+ //#warning( "Using sn* functions." )
		92	+ #define TIXML_SNPRINTF snprintf
		93	+ #define TIXML_VSNPRINTF vsnprintf
		94	+ static inline int TIXML_VSCPRINTF( const char* format, va_list va )
		95	+ {
		96	+ int len = vsnprintf( 0, 0, format, va );
		97	+ TIXMLASSERT( len >= 0 );
		98	+ return len;
		99	+ }
		100	+ #define TIXML_SSCANF sscanf
		101	+#endif
		102	+
		103	+
		104	+static const char LINE_FEED = (char)0x0a; // all line endings are normalized to LF
		105	+static const char LF = LINE_FEED;
		106	+static const char CARRIAGE_RETURN = (char)0x0d; // CR gets filtered out
		107	+static const char CR = CARRIAGE_RETURN;
		108	+static const char SINGLE_QUOTE = '\'';
		109	+static const char DOUBLE_QUOTE = '\"';
		110	+
		111	+// Bunch of unicode info at:
		112	+// http://www.unicode.org/faq/utf_bom.html
		113	+// ef bb bf (Microsoft "lead bytes") - designates UTF-8
		114	+
		115	+static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
		116	+static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
		117	+static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
		118	+
		119	+namespace tinyxml2
		120	+{
		121	+
		122	+struct Entity {
		123	+ const char* pattern;
		124	+ int length;
		125	+ char value;
		126	+};
		127	+
		128	+static const int NUM_ENTITIES = 5;
		129	+static const Entity entities[NUM_ENTITIES] = {
		130	+ { "quot", 4, DOUBLE_QUOTE },
		131	+ { "amp", 3, '&' },
		132	+ { "apos", 4, SINGLE_QUOTE },
		133	+ { "lt", 2, '<' },
		134	+ { "gt", 2, '>' }
		135	+};
		136	+
		137	+
		138	+StrPair::~StrPair()
		139	+{
		140	+ Reset();
		141	+}
		142	+
		143	+
		144	+void StrPair::TransferTo( StrPair* other )
		145	+{
		146	+ if ( this == other ) {
		147	+ return;
		148	+ }
		149	+ // This in effect implements the assignment operator by "moving"
		150	+ // ownership (as in auto_ptr).
		151	+
		152	+ TIXMLASSERT( other != 0 );
		153	+ TIXMLASSERT( other->_flags == 0 );
		154	+ TIXMLASSERT( other->_start == 0 );
		155	+ TIXMLASSERT( other->_end == 0 );
		156	+
		157	+ other->Reset();
		158	+
		159	+ other->_flags = _flags;
		160	+ other->_start = _start;
		161	+ other->_end = _end;
		162	+
		163	+ _flags = 0;
		164	+ _start = 0;
		165	+ _end = 0;
		166	+}
		167	+
		168	+
		169	+void StrPair::Reset()
		170	+{
		171	+ if ( _flags & NEEDS_DELETE ) {
		172	+ delete [] _start;
		173	+ }
		174	+ _flags = 0;
		175	+ _start = 0;
		176	+ _end = 0;
		177	+}
		178	+
		179	+
		180	+void StrPair::SetStr( const char* str, int flags )
		181	+{
		182	+ TIXMLASSERT( str );
		183	+ Reset();
		184	+ size_t len = strlen( str );
		185	+ TIXMLASSERT( _start == 0 );
		186	+ _start = new char[ len+1 ];
		187	+ memcpy( _start, str, len+1 );
		188	+ _end = _start + len;
		189	+ _flags = flags \| NEEDS_DELETE;
		190	+}
		191	+
		192	+
		193	+char* StrPair::ParseText( char* p, const char* endTag, int strFlags, int* curLineNumPtr )
		194	+{
		195	+ TIXMLASSERT( p );
		196	+ TIXMLASSERT( endTag && *endTag );
		197	+ TIXMLASSERT(curLineNumPtr);
		198	+
		199	+ char* start = p;
		200	+ char endChar = *endTag;
		201	+ size_t length = strlen( endTag );
		202	+
		203	+ // Inner loop of text parsing.
		204	+ while ( *p ) {
		205	+ if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
		206	+ Set( start, p, strFlags );
		207	+ return p + length;
		208	+ } else if (*p == '\n') {
		209	+ ++(*curLineNumPtr);
		210	+ }
		211	+ ++p;
		212	+ TIXMLASSERT( p );
		213	+ }
		214	+ return 0;
		215	+}
		216	+
		217	+
		218	+char* StrPair::ParseName( char* p )
		219	+{
		220	+ if ( !p \|\| !(*p) ) {
		221	+ return 0;
		222	+ }
		223	+ if ( !XMLUtil::IsNameStartChar( *p ) ) {
		224	+ return 0;
		225	+ }
		226	+
		227	+ char* const start = p;
		228	+ ++p;
		229	+ while ( p && XMLUtil::IsNameChar( p ) ) {
		230	+ ++p;
		231	+ }
		232	+
		233	+ Set( start, p, 0 );
		234	+ return p;
		235	+}
		236	+
		237	+
		238	+void StrPair::CollapseWhitespace()
		239	+{
		240	+ // Adjusting _start would cause undefined behavior on delete[]
		241	+ TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
		242	+ // Trim leading space.
		243	+ _start = XMLUtil::SkipWhiteSpace( _start, 0 );
		244	+
		245	+ if ( *_start ) {
		246	+ const char* p = _start; // the read pointer
		247	+ char* q = _start; // the write pointer
		248	+
		249	+ while( *p ) {
		250	+ if ( XMLUtil::IsWhiteSpace( *p )) {
		251	+ p = XMLUtil::SkipWhiteSpace( p, 0 );
		252	+ if ( *p == 0 ) {
		253	+ break; // don't write to q; this trims the trailing space.
		254	+ }
		255	+ *q = ' ';
		256	+ ++q;
		257	+ }
		258	+ q = p;
		259	+ ++q;
		260	+ ++p;
		261	+ }
		262	+ *q = 0;
		263	+ }
		264	+}
		265	+
		266	+
		267	+const char* StrPair::GetStr()
		268	+{
		269	+ TIXMLASSERT( _start );
		270	+ TIXMLASSERT( _end );
		271	+ if ( _flags & NEEDS_FLUSH ) {
		272	+ *_end = 0;
		273	+ _flags ^= NEEDS_FLUSH;
		274	+
		275	+ if ( _flags ) {
		276	+ const char* p = _start; // the read pointer
		277	+ char* q = _start; // the write pointer
		278	+
		279	+ while( p < _end ) {
		280	+ if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
		281	+ // CR-LF pair becomes LF
		282	+ // CR alone becomes LF
		283	+ // LF-CR becomes LF
		284	+ if ( *(p+1) == LF ) {
		285	+ p += 2;
		286	+ }
		287	+ else {
		288	+ ++p;
		289	+ }
		290	+ *q = LF;
		291	+ ++q;
		292	+ }
		293	+ else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
		294	+ if ( *(p+1) == CR ) {
		295	+ p += 2;
		296	+ }
		297	+ else {
		298	+ ++p;
		299	+ }
		300	+ *q = LF;
		301	+ ++q;
		302	+ }
		303	+ else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
		304	+ // Entities handled by tinyXML2:
		305	+ // - special entities in the entity table [in/out]
		306	+ // - numeric character reference [in]
		307	+ // 中 or 中
		308	+
		309	+ if ( *(p+1) == '#' ) {
		310	+ const int buflen = 10;
		311	+ char buf[buflen] = { 0 };
		312	+ int len = 0;
		313	+ char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
		314	+ if ( adjusted == 0 ) {
		315	+ q = p;
		316	+ ++p;
		317	+ ++q;
		318	+ }
		319	+ else {
		320	+ TIXMLASSERT( 0 <= len && len <= buflen );
		321	+ TIXMLASSERT( q + len <= adjusted );
		322	+ p = adjusted;
		323	+ memcpy( q, buf, len );
		324	+ q += len;
		325	+ }
		326	+ }
		327	+ else {
		328	+ bool entityFound = false;
		329	+ for( int i = 0; i < NUM_ENTITIES; ++i ) {
		330	+ const Entity& entity = entities[i];
		331	+ if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
		332	+ && *( p + entity.length + 1 ) == ';' ) {
		333	+ // Found an entity - convert.
		334	+ *q = entity.value;
		335	+ ++q;
		336	+ p += entity.length + 2;
		337	+ entityFound = true;
		338	+ break;
		339	+ }
		340	+ }
		341	+ if ( !entityFound ) {
		342	+ // fixme: treat as error?
		343	+ ++p;
		344	+ ++q;
		345	+ }
		346	+ }
		347	+ }
		348	+ else {
		349	+ q = p;
		350	+ ++p;
		351	+ ++q;
		352	+ }
		353	+ }
		354	+ *q = 0;
		355	+ }
		356	+ // The loop below has plenty going on, and this
		357	+ // is a less useful mode. Break it out.
		358	+ if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
		359	+ CollapseWhitespace();
		360	+ }
		361	+ _flags = (_flags & NEEDS_DELETE);
		362	+ }
		363	+ TIXMLASSERT( _start );
		364	+ return _start;
		365	+}
		366	+
		367	+
		368	+
		369	+
		370	+// --------- XMLUtil ----------- //
		371	+
		372	+const char* XMLUtil::writeBoolTrue = "true";
		373	+const char* XMLUtil::writeBoolFalse = "false";
		374	+
		375	+void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
		376	+{
		377	+ static const char* defTrue = "true";
		378	+ static const char* defFalse = "false";
		379	+
		380	+ writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
		381	+ writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
		382	+}
		383	+
		384	+
		385	+const char* XMLUtil::ReadBOM( const char* p, bool* bom )
		386	+{
		387	+ TIXMLASSERT( p );
		388	+ TIXMLASSERT( bom );
		389	+ *bom = false;
		390	+ const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
		391	+ // Check for BOM:
		392	+ if ( *(pu+0) == TIXML_UTF_LEAD_0
		393	+ && *(pu+1) == TIXML_UTF_LEAD_1
		394	+ && *(pu+2) == TIXML_UTF_LEAD_2 ) {
		395	+ *bom = true;
		396	+ p += 3;
		397	+ }
		398	+ TIXMLASSERT( p );
		399	+ return p;
		400	+}
		401	+
		402	+
		403	+void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
		404	+{
		405	+ const unsigned long BYTE_MASK = 0xBF;
		406	+ const unsigned long BYTE_MARK = 0x80;
		407	+ const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
		408	+
		409	+ if (input < 0x80) {
		410	+ *length = 1;
		411	+ }
		412	+ else if ( input < 0x800 ) {
		413	+ *length = 2;
		414	+ }
		415	+ else if ( input < 0x10000 ) {
		416	+ *length = 3;
		417	+ }
		418	+ else if ( input < 0x200000 ) {
		419	+ *length = 4;
		420	+ }
		421	+ else {
		422	+ *length = 0; // This code won't convert this correctly anyway.
		423	+ return;
		424	+ }
		425	+
		426	+ output += *length;
		427	+
		428	+ // Scary scary fall throughs are annotated with carefully designed comments
		429	+ // to suppress compiler warnings such as -Wimplicit-fallthrough in gcc
		430	+ switch (*length) {
		431	+ case 4:
		432	+ --output;
		433	+ *output = (char)((input \| BYTE_MARK) & BYTE_MASK);
		434	+ input >>= 6;
		435	+ //fall through
		436	+ case 3:
		437	+ --output;
		438	+ *output = (char)((input \| BYTE_MARK) & BYTE_MASK);
		439	+ input >>= 6;
		440	+ //fall through
		441	+ case 2:
		442	+ --output;
		443	+ *output = (char)((input \| BYTE_MARK) & BYTE_MASK);
		444	+ input >>= 6;
		445	+ //fall through
		446	+ case 1:
		447	+ --output;
		448	+ output = (char)(input \| FIRST_BYTE_MARK[length]);
		449	+ break;
		450	+ default:
		451	+ TIXMLASSERT( false );
		452	+ }
		453	+}
		454	+
		455	+
		456	+const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
		457	+{
		458	+ // Presume an entity, and pull it out.
		459	+ *length = 0;
		460	+
		461	+ if ( (p+1) == '#' && (p+2) ) {
		462	+ unsigned long ucs = 0;
		463	+ TIXMLASSERT( sizeof( ucs ) >= 4 );
		464	+ ptrdiff_t delta = 0;
		465	+ unsigned mult = 1;
		466	+ static const char SEMICOLON = ';';
		467	+
		468	+ if ( *(p+2) == 'x' ) {
		469	+ // Hexadecimal.
		470	+ const char* q = p+3;
		471	+ if ( !(*q) ) {
		472	+ return 0;
		473	+ }
		474	+
		475	+ q = strchr( q, SEMICOLON );
		476	+
		477	+ if ( !q ) {
		478	+ return 0;
		479	+ }
		480	+ TIXMLASSERT( *q == SEMICOLON );
		481	+
		482	+ delta = q-p;
		483	+ --q;
		484	+
		485	+ while ( *q != 'x' ) {
		486	+ unsigned int digit = 0;
		487	+
		488	+ if ( q >= '0' && q <= '9' ) {
		489	+ digit = *q - '0';
		490	+ }
		491	+ else if ( q >= 'a' && q <= 'f' ) {
		492	+ digit = *q - 'a' + 10;
		493	+ }
		494	+ else if ( q >= 'A' && q <= 'F' ) {
		495	+ digit = *q - 'A' + 10;
		496	+ }
		497	+ else {
		498	+ return 0;
		499	+ }
		500	+ TIXMLASSERT( digit < 16 );
		501	+ TIXMLASSERT( digit == 0 \|\| mult <= UINT_MAX / digit );
		502	+ const unsigned int digitScaled = mult * digit;
		503	+ TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
		504	+ ucs += digitScaled;
		505	+ TIXMLASSERT( mult <= UINT_MAX / 16 );
		506	+ mult *= 16;
		507	+ --q;
		508	+ }
		509	+ }
		510	+ else {
		511	+ // Decimal.
		512	+ const char* q = p+2;
		513	+ if ( !(*q) ) {
		514	+ return 0;
		515	+ }
		516	+
		517	+ q = strchr( q, SEMICOLON );
		518	+
		519	+ if ( !q ) {
		520	+ return 0;
		521	+ }
		522	+ TIXMLASSERT( *q == SEMICOLON );
		523	+
		524	+ delta = q-p;
		525	+ --q;
		526	+
		527	+ while ( *q != '#' ) {
		528	+ if ( q >= '0' && q <= '9' ) {
		529	+ const unsigned int digit = *q - '0';
		530	+ TIXMLASSERT( digit < 10 );
		531	+ TIXMLASSERT( digit == 0 \|\| mult <= UINT_MAX / digit );
		532	+ const unsigned int digitScaled = mult * digit;
		533	+ TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
		534	+ ucs += digitScaled;
		535	+ }
		536	+ else {
		537	+ return 0;
		538	+ }
		539	+ TIXMLASSERT( mult <= UINT_MAX / 10 );
		540	+ mult *= 10;
		541	+ --q;
		542	+ }
		543	+ }
		544	+ // convert the UCS to UTF-8
		545	+ ConvertUTF32ToUTF8( ucs, value, length );
		546	+ return p + delta + 1;
		547	+ }
		548	+ return p+1;
		549	+}
		550	+
		551	+
		552	+void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
		553	+{
		554	+ TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
		555	+}
		556	+
		557	+
		558	+void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
		559	+{
		560	+ TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
		561	+}
		562	+
		563	+
		564	+void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
		565	+{
		566	+ TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
		567	+}
		568	+
		569	+/*
		570	+ ToStr() of a number is a very tricky topic.
		571	+ https://github.com/leethomason/tinyxml2/issues/106
		572	+*/
		573	+void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
		574	+{
		575	+ TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
		576	+}
		577	+
		578	+
		579	+void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
		580	+{
		581	+ TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
		582	+}
		583	+
		584	+
		585	+void XMLUtil::ToStr(int64_t v, char* buffer, int bufferSize)
		586	+{
		587	+ // horrible syntax trick to make the compiler happy about %lld
		588	+ TIXML_SNPRINTF(buffer, bufferSize, "%lld", (long long)v);
		589	+}
		590	+
		591	+
		592	+bool XMLUtil::ToInt( const char* str, int* value )
		593	+{
		594	+ if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
		595	+ return true;
		596	+ }
		597	+ return false;
		598	+}
		599	+
		600	+bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
		601	+{
		602	+ if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
		603	+ return true;
		604	+ }
		605	+ return false;
		606	+}
		607	+
		608	+bool XMLUtil::ToBool( const char* str, bool* value )
		609	+{
		610	+ int ival = 0;
		611	+ if ( ToInt( str, &ival )) {
		612	+ *value = (ival==0) ? false : true;
		613	+ return true;
		614	+ }
		615	+ if ( StringEqual( str, "true" ) ) {
		616	+ *value = true;
		617	+ return true;
		618	+ }
		619	+ else if ( StringEqual( str, "false" ) ) {
		620	+ *value = false;
		621	+ return true;
		622	+ }
		623	+ return false;
		624	+}
		625	+
		626	+
		627	+bool XMLUtil::ToFloat( const char* str, float* value )
		628	+{
		629	+ if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
		630	+ return true;
		631	+ }
		632	+ return false;
		633	+}
		634	+
		635	+
		636	+bool XMLUtil::ToDouble( const char* str, double* value )
		637	+{
		638	+ if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
		639	+ return true;
		640	+ }
		641	+ return false;
		642	+}
		643	+
		644	+
		645	+bool XMLUtil::ToInt64(const char* str, int64_t* value)
		646	+{
		647	+ long long v = 0; // horrible syntax trick to make the compiler happy about %lld
		648	+ if (TIXML_SSCANF(str, "%lld", &v) == 1) {
		649	+ *value = (int64_t)v;
		650	+ return true;
		651	+ }
		652	+ return false;
		653	+}
		654	+
		655	+
		656	+char* XMLDocument::Identify( char* p, XMLNode** node )
		657	+{
		658	+ TIXMLASSERT( node );
		659	+ TIXMLASSERT( p );
		660	+ char* const start = p;
		661	+ int const startLine = _parseCurLineNum;
		662	+ p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
		663	+ if( !*p ) {
		664	+ *node = 0;
		665	+ TIXMLASSERT( p );
		666	+ return p;
		667	+ }
		668	+
		669	+ // These strings define the matching patterns:
		670	+ static const char* xmlHeader = { "<?" };
		671	+ static const char* commentHeader = { "<!--" };
		672	+ static const char* cdataHeader = { "<![CDATA[" };
		673	+ static const char* dtdHeader = { "<!" };
		674	+ static const char* elementHeader = { "<" }; // and a header for everything else; check last.
		675	+
		676	+ static const int xmlHeaderLen = 2;
		677	+ static const int commentHeaderLen = 4;
		678	+ static const int cdataHeaderLen = 9;
		679	+ static const int dtdHeaderLen = 2;
		680	+ static const int elementHeaderLen = 1;
		681	+
		682	+ TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool
		683	+ TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool
		684	+ XMLNode* returnNode = 0;
		685	+ if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
		686	+ returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
		687	+ returnNode->_parseLineNum = _parseCurLineNum;
		688	+ p += xmlHeaderLen;
		689	+ }
		690	+ else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
		691	+ returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
		692	+ returnNode->_parseLineNum = _parseCurLineNum;
		693	+ p += commentHeaderLen;
		694	+ }
		695	+ else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
		696	+ XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
		697	+ returnNode = text;
		698	+ returnNode->_parseLineNum = _parseCurLineNum;
		699	+ p += cdataHeaderLen;
		700	+ text->SetCData( true );
		701	+ }
		702	+ else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
		703	+ returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
		704	+ returnNode->_parseLineNum = _parseCurLineNum;
		705	+ p += dtdHeaderLen;
		706	+ }
		707	+ else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
		708	+ returnNode = CreateUnlinkedNode<XMLElement>( _elementPool );
		709	+ returnNode->_parseLineNum = _parseCurLineNum;
		710	+ p += elementHeaderLen;
		711	+ }
		712	+ else {
		713	+ returnNode = CreateUnlinkedNode<XMLText>( _textPool );
		714	+ returnNode->_parseLineNum = _parseCurLineNum; // Report line of first non-whitespace character
		715	+ p = start; // Back it up, all the text counts.
		716	+ _parseCurLineNum = startLine;
		717	+ }
		718	+
		719	+ TIXMLASSERT( returnNode );
		720	+ TIXMLASSERT( p );
		721	+ *node = returnNode;
		722	+ return p;
		723	+}
		724	+
		725	+
		726	+bool XMLDocument::Accept( XMLVisitor* visitor ) const
		727	+{
		728	+ TIXMLASSERT( visitor );
		729	+ if ( visitor->VisitEnter( *this ) ) {
		730	+ for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
		731	+ if ( !node->Accept( visitor ) ) {
		732	+ break;
		733	+ }
		734	+ }
		735	+ }
		736	+ return visitor->VisitExit( *this );
		737	+}
		738	+
		739	+
		740	+// --------- XMLNode ----------- //
		741	+
		742	+XMLNode::XMLNode( XMLDocument* doc ) :
		743	+ _document( doc ),
		744	+ _parent( 0 ),
		745	+ _value(),
		746	+ _parseLineNum( 0 ),
		747	+ _firstChild( 0 ), _lastChild( 0 ),
		748	+ _prev( 0 ), _next( 0 ),
		749	+ _userData( 0 ),
		750	+ _memPool( 0 )
		751	+{
		752	+}
		753	+
		754	+
		755	+XMLNode::~XMLNode()
		756	+{
		757	+ DeleteChildren();
		758	+ if ( _parent ) {
		759	+ _parent->Unlink( this );
		760	+ }
		761	+}
		762	+
		763	+const char* XMLNode::Value() const
		764	+{
		765	+ // Edge case: XMLDocuments don't have a Value. Return null.
		766	+ if ( this->ToDocument() )
		767	+ return 0;
		768	+ return _value.GetStr();
		769	+}
		770	+
		771	+void XMLNode::SetValue( const char* str, bool staticMem )
		772	+{
		773	+ if ( staticMem ) {
		774	+ _value.SetInternedStr( str );
		775	+ }
		776	+ else {
		777	+ _value.SetStr( str );
		778	+ }
		779	+}
		780	+
		781	+XMLNode* XMLNode::DeepClone(XMLDocument* target) const
		782	+{
		783	+ XMLNode* clone = this->ShallowClone(target);
		784	+ if (!clone) return 0;
		785	+
		786	+ for (const XMLNode* child = this->FirstChild(); child; child = child->NextSibling()) {
		787	+ XMLNode* childClone = child->DeepClone(target);
		788	+ TIXMLASSERT(childClone);
		789	+ clone->InsertEndChild(childClone);
		790	+ }
		791	+ return clone;
		792	+}
		793	+
		794	+void XMLNode::DeleteChildren()
		795	+{
		796	+ while( _firstChild ) {
		797	+ TIXMLASSERT( _lastChild );
		798	+ DeleteChild( _firstChild );
		799	+ }
		800	+ _firstChild = _lastChild = 0;
		801	+}
		802	+
		803	+
		804	+void XMLNode::Unlink( XMLNode* child )
		805	+{
		806	+ TIXMLASSERT( child );
		807	+ TIXMLASSERT( child->_document == _document );
		808	+ TIXMLASSERT( child->_parent == this );
		809	+ if ( child == _firstChild ) {
		810	+ _firstChild = _firstChild->_next;
		811	+ }
		812	+ if ( child == _lastChild ) {
		813	+ _lastChild = _lastChild->_prev;
		814	+ }
		815	+
		816	+ if ( child->_prev ) {
		817	+ child->_prev->_next = child->_next;
		818	+ }
		819	+ if ( child->_next ) {
		820	+ child->_next->_prev = child->_prev;
		821	+ }
		822	+ child->_next = 0;
		823	+ child->_prev = 0;
		824	+ child->_parent = 0;
		825	+}
		826	+
		827	+
		828	+void XMLNode::DeleteChild( XMLNode* node )
		829	+{
		830	+ TIXMLASSERT( node );
		831	+ TIXMLASSERT( node->_document == _document );
		832	+ TIXMLASSERT( node->_parent == this );
		833	+ Unlink( node );
		834	+ TIXMLASSERT(node->_prev == 0);
		835	+ TIXMLASSERT(node->_next == 0);
		836	+ TIXMLASSERT(node->_parent == 0);
		837	+ DeleteNode( node );
		838	+}
		839	+
		840	+
		841	+XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
		842	+{
		843	+ TIXMLASSERT( addThis );
		844	+ if ( addThis->_document != _document ) {
		845	+ TIXMLASSERT( false );
		846	+ return 0;
		847	+ }
		848	+ InsertChildPreamble( addThis );
		849	+
		850	+ if ( _lastChild ) {
		851	+ TIXMLASSERT( _firstChild );
		852	+ TIXMLASSERT( _lastChild->_next == 0 );
		853	+ _lastChild->_next = addThis;
		854	+ addThis->_prev = _lastChild;
		855	+ _lastChild = addThis;
		856	+
		857	+ addThis->_next = 0;
		858	+ }
		859	+ else {
		860	+ TIXMLASSERT( _firstChild == 0 );
		861	+ _firstChild = _lastChild = addThis;
		862	+
		863	+ addThis->_prev = 0;
		864	+ addThis->_next = 0;
		865	+ }
		866	+ addThis->_parent = this;
		867	+ return addThis;
		868	+}
		869	+
		870	+
		871	+XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
		872	+{
		873	+ TIXMLASSERT( addThis );
		874	+ if ( addThis->_document != _document ) {
		875	+ TIXMLASSERT( false );
		876	+ return 0;
		877	+ }
		878	+ InsertChildPreamble( addThis );
		879	+
		880	+ if ( _firstChild ) {
		881	+ TIXMLASSERT( _lastChild );
		882	+ TIXMLASSERT( _firstChild->_prev == 0 );
		883	+
		884	+ _firstChild->_prev = addThis;
		885	+ addThis->_next = _firstChild;
		886	+ _firstChild = addThis;
		887	+
		888	+ addThis->_prev = 0;
		889	+ }
		890	+ else {
		891	+ TIXMLASSERT( _lastChild == 0 );
		892	+ _firstChild = _lastChild = addThis;
		893	+
		894	+ addThis->_prev = 0;
		895	+ addThis->_next = 0;
		896	+ }
		897	+ addThis->_parent = this;
		898	+ return addThis;
		899	+}
		900	+
		901	+
		902	+XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
		903	+{
		904	+ TIXMLASSERT( addThis );
		905	+ if ( addThis->_document != _document ) {
		906	+ TIXMLASSERT( false );
		907	+ return 0;
		908	+ }
		909	+
		910	+ TIXMLASSERT( afterThis );
		911	+
		912	+ if ( afterThis->_parent != this ) {
		913	+ TIXMLASSERT( false );
		914	+ return 0;
		915	+ }
		916	+ if ( afterThis == addThis ) {
		917	+ // Current state: BeforeThis -> AddThis -> OneAfterAddThis
		918	+ // Now AddThis must disappear from it's location and then
		919	+ // reappear between BeforeThis and OneAfterAddThis.
		920	+ // So just leave it where it is.
		921	+ return addThis;
		922	+ }
		923	+
		924	+ if ( afterThis->_next == 0 ) {
		925	+ // The last node or the only node.
		926	+ return InsertEndChild( addThis );
		927	+ }
		928	+ InsertChildPreamble( addThis );
		929	+ addThis->_prev = afterThis;
		930	+ addThis->_next = afterThis->_next;
		931	+ afterThis->_next->_prev = addThis;
		932	+ afterThis->_next = addThis;
		933	+ addThis->_parent = this;
		934	+ return addThis;
		935	+}
		936	+
		937	+
		938	+
		939	+
		940	+const XMLElement* XMLNode::FirstChildElement( const char* name ) const
		941	+{
		942	+ for( const XMLNode* node = _firstChild; node; node = node->_next ) {
		943	+ const XMLElement* element = node->ToElementWithName( name );
		944	+ if ( element ) {
		945	+ return element;
		946	+ }
		947	+ }
		948	+ return 0;
		949	+}
		950	+
		951	+
		952	+const XMLElement* XMLNode::LastChildElement( const char* name ) const
		953	+{
		954	+ for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
		955	+ const XMLElement* element = node->ToElementWithName( name );
		956	+ if ( element ) {
		957	+ return element;
		958	+ }
		959	+ }
		960	+ return 0;
		961	+}
		962	+
		963	+
		964	+const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
		965	+{
		966	+ for( const XMLNode* node = _next; node; node = node->_next ) {
		967	+ const XMLElement* element = node->ToElementWithName( name );
		968	+ if ( element ) {
		969	+ return element;
		970	+ }
		971	+ }
		972	+ return 0;
		973	+}
		974	+
		975	+
		976	+const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
		977	+{
		978	+ for( const XMLNode* node = _prev; node; node = node->_prev ) {
		979	+ const XMLElement* element = node->ToElementWithName( name );
		980	+ if ( element ) {
		981	+ return element;
		982	+ }
		983	+ }
		984	+ return 0;
		985	+}
		986	+
		987	+
		988	+char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
		989	+{
		990	+ // This is a recursive method, but thinking about it "at the current level"
		991	+ // it is a pretty simple flat list:
		992	+ // <foo/>
		993	+ // <!-- comment -->
		994	+ //
		995	+ // With a special case:
		996	+ // <foo>
		997	+ // </foo>
		998	+ // <!-- comment -->
		999	+ //
		1000	+ // Where the closing element (/foo) must be the next thing after the opening
		1001	+ // element, and the names must match. BUT the tricky bit is that the closing
		1002	+ // element will be read by the child.
		1003	+ //
		1004	+ // 'endTag' is the end tag for this node, it is returned by a call to a child.
		1005	+ // 'parentEnd' is the end tag for the parent, which is filled in and returned.
		1006	+
		1007	+ XMLDocument::DepthTracker tracker(_document);
		1008	+ if (_document->Error())
		1009	+ return 0;
		1010	+
		1011	+ while( p && *p ) {
		1012	+ XMLNode* node = 0;
		1013	+
		1014	+ p = _document->Identify( p, &node );
		1015	+ TIXMLASSERT( p );
		1016	+ if ( node == 0 ) {
		1017	+ break;
		1018	+ }
		1019	+
		1020	+ int initialLineNum = node->_parseLineNum;
		1021	+
		1022	+ StrPair endTag;
		1023	+ p = node->ParseDeep( p, &endTag, curLineNumPtr );
		1024	+ if ( !p ) {
		1025	+ DeleteNode( node );
		1026	+ if ( !_document->Error() ) {
		1027	+ _document->SetError( XML_ERROR_PARSING, initialLineNum, 0);
		1028	+ }
		1029	+ break;
		1030	+ }
		1031	+
		1032	+ XMLDeclaration* decl = node->ToDeclaration();
		1033	+ if ( decl ) {
		1034	+ // Declarations are only allowed at document level
		1035	+ bool wellLocated = ( ToDocument() != 0 );
		1036	+ if ( wellLocated ) {
		1037	+ // Multiple declarations are allowed but all declarations
		1038	+ // must occur before anything else
		1039	+ for ( const XMLNode* existingNode = _document->FirstChild(); existingNode; existingNode = existingNode->NextSibling() ) {
		1040	+ if ( !existingNode->ToDeclaration() ) {
		1041	+ wellLocated = false;
		1042	+ break;
		1043	+ }
		1044	+ }
		1045	+ }
		1046	+ if ( !wellLocated ) {
		1047	+ _document->SetError( XML_ERROR_PARSING_DECLARATION, initialLineNum, "XMLDeclaration value=%s", decl->Value());
		1048	+ DeleteNode( node );
		1049	+ break;
		1050	+ }
		1051	+ }
		1052	+
		1053	+ XMLElement* ele = node->ToElement();
		1054	+ if ( ele ) {
		1055	+ // We read the end tag. Return it to the parent.
		1056	+ if ( ele->ClosingType() == XMLElement::CLOSING ) {
		1057	+ if ( parentEndTag ) {
		1058	+ ele->_value.TransferTo( parentEndTag );
		1059	+ }
		1060	+ node->_memPool->SetTracked(); // created and then immediately deleted.
		1061	+ DeleteNode( node );
		1062	+ return p;
		1063	+ }
		1064	+
		1065	+ // Handle an end tag returned to this level.
		1066	+ // And handle a bunch of annoying errors.
		1067	+ bool mismatch = false;
		1068	+ if ( endTag.Empty() ) {
		1069	+ if ( ele->ClosingType() == XMLElement::OPEN ) {
		1070	+ mismatch = true;
		1071	+ }
		1072	+ }
		1073	+ else {
		1074	+ if ( ele->ClosingType() != XMLElement::OPEN ) {
		1075	+ mismatch = true;
		1076	+ }
		1077	+ else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
		1078	+ mismatch = true;
		1079	+ }
		1080	+ }
		1081	+ if ( mismatch ) {
		1082	+ _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, initialLineNum, "XMLElement name=%s", ele->Name());
		1083	+ DeleteNode( node );
		1084	+ break;
		1085	+ }
		1086	+ }
		1087	+ InsertEndChild( node );
		1088	+ }
		1089	+ return 0;
		1090	+}
		1091	+
		1092	+/static/ void XMLNode::DeleteNode( XMLNode* node )
		1093	+{
		1094	+ if ( node == 0 ) {
		1095	+ return;
		1096	+ }
		1097	+ TIXMLASSERT(node->_document);
		1098	+ if (!node->ToDocument()) {
		1099	+ node->_document->MarkInUse(node);
		1100	+ }
		1101	+
		1102	+ MemPool* pool = node->_memPool;
		1103	+ node->~XMLNode();
		1104	+ pool->Free( node );
		1105	+}
		1106	+
		1107	+void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
		1108	+{
		1109	+ TIXMLASSERT( insertThis );
		1110	+ TIXMLASSERT( insertThis->_document == _document );
		1111	+
		1112	+ if (insertThis->_parent) {
		1113	+ insertThis->_parent->Unlink( insertThis );
		1114	+ }
		1115	+ else {
		1116	+ insertThis->_document->MarkInUse(insertThis);
		1117	+ insertThis->_memPool->SetTracked();
		1118	+ }
		1119	+}
		1120	+
		1121	+const XMLElement* XMLNode::ToElementWithName( const char* name ) const
		1122	+{
		1123	+ const XMLElement* element = this->ToElement();
		1124	+ if ( element == 0 ) {
		1125	+ return 0;
		1126	+ }
		1127	+ if ( name == 0 ) {
		1128	+ return element;
		1129	+ }
		1130	+ if ( XMLUtil::StringEqual( element->Name(), name ) ) {
		1131	+ return element;
		1132	+ }
		1133	+ return 0;
		1134	+}
		1135	+
		1136	+// --------- XMLText ---------- //
		1137	+char* XMLText::ParseDeep( char* p, StrPair, int curLineNumPtr )
		1138	+{
		1139	+ if ( this->CData() ) {
		1140	+ p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
		1141	+ if ( !p ) {
		1142	+ _document->SetError( XML_ERROR_PARSING_CDATA, _parseLineNum, 0 );
		1143	+ }
		1144	+ return p;
		1145	+ }
		1146	+ else {
		1147	+ int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
		1148	+ if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
		1149	+ flags \|= StrPair::NEEDS_WHITESPACE_COLLAPSING;
		1150	+ }
		1151	+
		1152	+ p = _value.ParseText( p, "<", flags, curLineNumPtr );
		1153	+ if ( p && *p ) {
		1154	+ return p-1;
		1155	+ }
		1156	+ if ( !p ) {
		1157	+ _document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, 0 );
		1158	+ }
		1159	+ }
		1160	+ return 0;
		1161	+}
		1162	+
		1163	+
		1164	+XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
		1165	+{
		1166	+ if ( !doc ) {
		1167	+ doc = _document;
		1168	+ }
		1169	+ XMLText* text = doc->NewText( Value() ); // fixme: this will always allocate memory. Intern?
		1170	+ text->SetCData( this->CData() );
		1171	+ return text;
		1172	+}
		1173	+
		1174	+
		1175	+bool XMLText::ShallowEqual( const XMLNode* compare ) const
		1176	+{
		1177	+ TIXMLASSERT( compare );
		1178	+ const XMLText* text = compare->ToText();
		1179	+ return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
		1180	+}
		1181	+
		1182	+
		1183	+bool XMLText::Accept( XMLVisitor* visitor ) const
		1184	+{
		1185	+ TIXMLASSERT( visitor );
		1186	+ return visitor->Visit( *this );
		1187	+}
		1188	+
		1189	+
		1190	+// --------- XMLComment ---------- //
		1191	+
		1192	+XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )
		1193	+{
		1194	+}
		1195	+
		1196	+
		1197	+XMLComment::~XMLComment()
		1198	+{
		1199	+}
		1200	+
		1201	+
		1202	+char* XMLComment::ParseDeep( char* p, StrPair, int curLineNumPtr )
		1203	+{
		1204	+ // Comment parses as text.
		1205	+ p = _value.ParseText( p, "-->", StrPair::COMMENT, curLineNumPtr );
		1206	+ if ( p == 0 ) {
		1207	+ _document->SetError( XML_ERROR_PARSING_COMMENT, _parseLineNum, 0 );
		1208	+ }
		1209	+ return p;
		1210	+}
		1211	+
		1212	+
		1213	+XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
		1214	+{
		1215	+ if ( !doc ) {
		1216	+ doc = _document;
		1217	+ }
		1218	+ XMLComment* comment = doc->NewComment( Value() ); // fixme: this will always allocate memory. Intern?
		1219	+ return comment;
		1220	+}
		1221	+
		1222	+
		1223	+bool XMLComment::ShallowEqual( const XMLNode* compare ) const
		1224	+{
		1225	+ TIXMLASSERT( compare );
		1226	+ const XMLComment* comment = compare->ToComment();
		1227	+ return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
		1228	+}
		1229	+
		1230	+
		1231	+bool XMLComment::Accept( XMLVisitor* visitor ) const
		1232	+{
		1233	+ TIXMLASSERT( visitor );
		1234	+ return visitor->Visit( *this );
		1235	+}
		1236	+
		1237	+
		1238	+// --------- XMLDeclaration ---------- //
		1239	+
		1240	+XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )
		1241	+{
		1242	+}
		1243	+
		1244	+
		1245	+XMLDeclaration::~XMLDeclaration()
		1246	+{
		1247	+ //printf( "~XMLDeclaration\n" );
		1248	+}
		1249	+
		1250	+
		1251	+char* XMLDeclaration::ParseDeep( char* p, StrPair, int curLineNumPtr )
		1252	+{
		1253	+ // Declaration parses as text.
		1254	+ p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
		1255	+ if ( p == 0 ) {
		1256	+ _document->SetError( XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0 );
		1257	+ }
		1258	+ return p;
		1259	+}
		1260	+
		1261	+
		1262	+XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
		1263	+{
		1264	+ if ( !doc ) {
		1265	+ doc = _document;
		1266	+ }
		1267	+ XMLDeclaration* dec = doc->NewDeclaration( Value() ); // fixme: this will always allocate memory. Intern?
		1268	+ return dec;
		1269	+}
		1270	+
		1271	+
		1272	+bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
		1273	+{
		1274	+ TIXMLASSERT( compare );
		1275	+ const XMLDeclaration* declaration = compare->ToDeclaration();
		1276	+ return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
		1277	+}
		1278	+
		1279	+
		1280	+
		1281	+bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
		1282	+{
		1283	+ TIXMLASSERT( visitor );
		1284	+ return visitor->Visit( *this );
		1285	+}
		1286	+
		1287	+// --------- XMLUnknown ---------- //
		1288	+
		1289	+XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )
		1290	+{
		1291	+}
		1292	+
		1293	+
		1294	+XMLUnknown::~XMLUnknown()
		1295	+{
		1296	+}
		1297	+
		1298	+
		1299	+char* XMLUnknown::ParseDeep( char* p, StrPair, int curLineNumPtr )
		1300	+{
		1301	+ // Unknown parses as text.
		1302	+ p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
		1303	+ if ( !p ) {
		1304	+ _document->SetError( XML_ERROR_PARSING_UNKNOWN, _parseLineNum, 0 );
		1305	+ }
		1306	+ return p;
		1307	+}
		1308	+
		1309	+
		1310	+XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
		1311	+{
		1312	+ if ( !doc ) {
		1313	+ doc = _document;
		1314	+ }
		1315	+ XMLUnknown* text = doc->NewUnknown( Value() ); // fixme: this will always allocate memory. Intern?
		1316	+ return text;
		1317	+}
		1318	+
		1319	+
		1320	+bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
		1321	+{
		1322	+ TIXMLASSERT( compare );
		1323	+ const XMLUnknown* unknown = compare->ToUnknown();
		1324	+ return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
		1325	+}
		1326	+
		1327	+
		1328	+bool XMLUnknown::Accept( XMLVisitor* visitor ) const
		1329	+{
		1330	+ TIXMLASSERT( visitor );
		1331	+ return visitor->Visit( *this );
		1332	+}
		1333	+
		1334	+// --------- XMLAttribute ---------- //
		1335	+
		1336	+const char* XMLAttribute::Name() const
		1337	+{
		1338	+ return _name.GetStr();
		1339	+}
		1340	+
		1341	+const char* XMLAttribute::Value() const
		1342	+{
		1343	+ return _value.GetStr();
		1344	+}
		1345	+
		1346	+char* XMLAttribute::ParseDeep( char* p, bool processEntities, int* curLineNumPtr )
		1347	+{
		1348	+ // Parse using the name rules: bug fix, was using ParseText before
		1349	+ p = _name.ParseName( p );
		1350	+ if ( !p \|\| !*p ) {
		1351	+ return 0;
		1352	+ }
		1353	+
		1354	+ // Skip white space before =
		1355	+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
		1356	+ if ( *p != '=' ) {
		1357	+ return 0;
		1358	+ }
		1359	+
		1360	+ ++p; // move up to opening quote
		1361	+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
		1362	+ if ( p != '\"' && p != '\'' ) {
		1363	+ return 0;
		1364	+ }
		1365	+
		1366	+ char endTag[2] = { *p, 0 };
		1367	+ ++p; // move past opening quote
		1368	+
		1369	+ p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES, curLineNumPtr );
		1370	+ return p;
		1371	+}
		1372	+
		1373	+
		1374	+void XMLAttribute::SetName( const char* n )
		1375	+{
		1376	+ _name.SetStr( n );
		1377	+}
		1378	+
		1379	+
		1380	+XMLError XMLAttribute::QueryIntValue( int* value ) const
		1381	+{
		1382	+ if ( XMLUtil::ToInt( Value(), value )) {
		1383	+ return XML_SUCCESS;
		1384	+ }
		1385	+ return XML_WRONG_ATTRIBUTE_TYPE;
		1386	+}
		1387	+
		1388	+
		1389	+XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
		1390	+{
		1391	+ if ( XMLUtil::ToUnsigned( Value(), value )) {
		1392	+ return XML_SUCCESS;
		1393	+ }
		1394	+ return XML_WRONG_ATTRIBUTE_TYPE;
		1395	+}
		1396	+
		1397	+
		1398	+XMLError XMLAttribute::QueryInt64Value(int64_t* value) const
		1399	+{
		1400	+ if (XMLUtil::ToInt64(Value(), value)) {
		1401	+ return XML_SUCCESS;
		1402	+ }
		1403	+ return XML_WRONG_ATTRIBUTE_TYPE;
		1404	+}
		1405	+
		1406	+
		1407	+XMLError XMLAttribute::QueryBoolValue( bool* value ) const
		1408	+{
		1409	+ if ( XMLUtil::ToBool( Value(), value )) {
		1410	+ return XML_SUCCESS;
		1411	+ }
		1412	+ return XML_WRONG_ATTRIBUTE_TYPE;
		1413	+}
		1414	+
		1415	+
		1416	+XMLError XMLAttribute::QueryFloatValue( float* value ) const
		1417	+{
		1418	+ if ( XMLUtil::ToFloat( Value(), value )) {
		1419	+ return XML_SUCCESS;
		1420	+ }
		1421	+ return XML_WRONG_ATTRIBUTE_TYPE;
		1422	+}
		1423	+
		1424	+
		1425	+XMLError XMLAttribute::QueryDoubleValue( double* value ) const
		1426	+{
		1427	+ if ( XMLUtil::ToDouble( Value(), value )) {
		1428	+ return XML_SUCCESS;
		1429	+ }
		1430	+ return XML_WRONG_ATTRIBUTE_TYPE;
		1431	+}
		1432	+
		1433	+
		1434	+void XMLAttribute::SetAttribute( const char* v )
		1435	+{
		1436	+ _value.SetStr( v );
		1437	+}
		1438	+
		1439	+
		1440	+void XMLAttribute::SetAttribute( int v )
		1441	+{
		1442	+ char buf[BUF_SIZE];
		1443	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1444	+ _value.SetStr( buf );
		1445	+}
		1446	+
		1447	+
		1448	+void XMLAttribute::SetAttribute( unsigned v )
		1449	+{
		1450	+ char buf[BUF_SIZE];
		1451	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1452	+ _value.SetStr( buf );
		1453	+}
		1454	+
		1455	+
		1456	+void XMLAttribute::SetAttribute(int64_t v)
		1457	+{
		1458	+ char buf[BUF_SIZE];
		1459	+ XMLUtil::ToStr(v, buf, BUF_SIZE);
		1460	+ _value.SetStr(buf);
		1461	+}
		1462	+
		1463	+
		1464	+
		1465	+void XMLAttribute::SetAttribute( bool v )
		1466	+{
		1467	+ char buf[BUF_SIZE];
		1468	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1469	+ _value.SetStr( buf );
		1470	+}
		1471	+
		1472	+void XMLAttribute::SetAttribute( double v )
		1473	+{
		1474	+ char buf[BUF_SIZE];
		1475	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1476	+ _value.SetStr( buf );
		1477	+}
		1478	+
		1479	+void XMLAttribute::SetAttribute( float v )
		1480	+{
		1481	+ char buf[BUF_SIZE];
		1482	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1483	+ _value.SetStr( buf );
		1484	+}
		1485	+
		1486	+
		1487	+// --------- XMLElement ---------- //
		1488	+XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
		1489	+ _closingType( OPEN ),
		1490	+ _rootAttribute( 0 )
		1491	+{
		1492	+}
		1493	+
		1494	+
		1495	+XMLElement::~XMLElement()
		1496	+{
		1497	+ while( _rootAttribute ) {
		1498	+ XMLAttribute* next = _rootAttribute->_next;
		1499	+ DeleteAttribute( _rootAttribute );
		1500	+ _rootAttribute = next;
		1501	+ }
		1502	+}
		1503	+
		1504	+
		1505	+const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
		1506	+{
		1507	+ for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
		1508	+ if ( XMLUtil::StringEqual( a->Name(), name ) ) {
		1509	+ return a;
		1510	+ }
		1511	+ }
		1512	+ return 0;
		1513	+}
		1514	+
		1515	+
		1516	+const char* XMLElement::Attribute( const char* name, const char* value ) const
		1517	+{
		1518	+ const XMLAttribute* a = FindAttribute( name );
		1519	+ if ( !a ) {
		1520	+ return 0;
		1521	+ }
		1522	+ if ( !value \|\| XMLUtil::StringEqual( a->Value(), value )) {
		1523	+ return a->Value();
		1524	+ }
		1525	+ return 0;
		1526	+}
		1527	+
		1528	+int XMLElement::IntAttribute(const char* name, int defaultValue) const
		1529	+{
		1530	+ int i = defaultValue;
		1531	+ QueryIntAttribute(name, &i);
		1532	+ return i;
		1533	+}
		1534	+
		1535	+unsigned XMLElement::UnsignedAttribute(const char* name, unsigned defaultValue) const
		1536	+{
		1537	+ unsigned i = defaultValue;
		1538	+ QueryUnsignedAttribute(name, &i);
		1539	+ return i;
		1540	+}
		1541	+
		1542	+int64_t XMLElement::Int64Attribute(const char* name, int64_t defaultValue) const
		1543	+{
		1544	+ int64_t i = defaultValue;
		1545	+ QueryInt64Attribute(name, &i);
		1546	+ return i;
		1547	+}
		1548	+
		1549	+bool XMLElement::BoolAttribute(const char* name, bool defaultValue) const
		1550	+{
		1551	+ bool b = defaultValue;
		1552	+ QueryBoolAttribute(name, &b);
		1553	+ return b;
		1554	+}
		1555	+
		1556	+double XMLElement::DoubleAttribute(const char* name, double defaultValue) const
		1557	+{
		1558	+ double d = defaultValue;
		1559	+ QueryDoubleAttribute(name, &d);
		1560	+ return d;
		1561	+}
		1562	+
		1563	+float XMLElement::FloatAttribute(const char* name, float defaultValue) const
		1564	+{
		1565	+ float f = defaultValue;
		1566	+ QueryFloatAttribute(name, &f);
		1567	+ return f;
		1568	+}
		1569	+
		1570	+const char* XMLElement::GetText() const
		1571	+{
		1572	+ if ( FirstChild() && FirstChild()->ToText() ) {
		1573	+ return FirstChild()->Value();
		1574	+ }
		1575	+ return 0;
		1576	+}
		1577	+
		1578	+
		1579	+void XMLElement::SetText( const char* inText )
		1580	+{
		1581	+ if ( FirstChild() && FirstChild()->ToText() )
		1582	+ FirstChild()->SetValue( inText );
		1583	+ else {
		1584	+ XMLText* theText = GetDocument()->NewText( inText );
		1585	+ InsertFirstChild( theText );
		1586	+ }
		1587	+}
		1588	+
		1589	+
		1590	+void XMLElement::SetText( int v )
		1591	+{
		1592	+ char buf[BUF_SIZE];
		1593	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1594	+ SetText( buf );
		1595	+}
		1596	+
		1597	+
		1598	+void XMLElement::SetText( unsigned v )
		1599	+{
		1600	+ char buf[BUF_SIZE];
		1601	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1602	+ SetText( buf );
		1603	+}
		1604	+
		1605	+
		1606	+void XMLElement::SetText(int64_t v)
		1607	+{
		1608	+ char buf[BUF_SIZE];
		1609	+ XMLUtil::ToStr(v, buf, BUF_SIZE);
		1610	+ SetText(buf);
		1611	+}
		1612	+
		1613	+
		1614	+void XMLElement::SetText( bool v )
		1615	+{
		1616	+ char buf[BUF_SIZE];
		1617	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1618	+ SetText( buf );
		1619	+}
		1620	+
		1621	+
		1622	+void XMLElement::SetText( float v )
		1623	+{
		1624	+ char buf[BUF_SIZE];
		1625	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1626	+ SetText( buf );
		1627	+}
		1628	+
		1629	+
		1630	+void XMLElement::SetText( double v )
		1631	+{
		1632	+ char buf[BUF_SIZE];
		1633	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		1634	+ SetText( buf );
		1635	+}
		1636	+
		1637	+
		1638	+XMLError XMLElement::QueryIntText( int* ival ) const
		1639	+{
		1640	+ if ( FirstChild() && FirstChild()->ToText() ) {
		1641	+ const char* t = FirstChild()->Value();
		1642	+ if ( XMLUtil::ToInt( t, ival ) ) {
		1643	+ return XML_SUCCESS;
		1644	+ }
		1645	+ return XML_CAN_NOT_CONVERT_TEXT;
		1646	+ }
		1647	+ return XML_NO_TEXT_NODE;
		1648	+}
		1649	+
		1650	+
		1651	+XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
		1652	+{
		1653	+ if ( FirstChild() && FirstChild()->ToText() ) {
		1654	+ const char* t = FirstChild()->Value();
		1655	+ if ( XMLUtil::ToUnsigned( t, uval ) ) {
		1656	+ return XML_SUCCESS;
		1657	+ }
		1658	+ return XML_CAN_NOT_CONVERT_TEXT;
		1659	+ }
		1660	+ return XML_NO_TEXT_NODE;
		1661	+}
		1662	+
		1663	+
		1664	+XMLError XMLElement::QueryInt64Text(int64_t* ival) const
		1665	+{
		1666	+ if (FirstChild() && FirstChild()->ToText()) {
		1667	+ const char* t = FirstChild()->Value();
		1668	+ if (XMLUtil::ToInt64(t, ival)) {
		1669	+ return XML_SUCCESS;
		1670	+ }
		1671	+ return XML_CAN_NOT_CONVERT_TEXT;
		1672	+ }
		1673	+ return XML_NO_TEXT_NODE;
		1674	+}
		1675	+
		1676	+
		1677	+XMLError XMLElement::QueryBoolText( bool* bval ) const
		1678	+{
		1679	+ if ( FirstChild() && FirstChild()->ToText() ) {
		1680	+ const char* t = FirstChild()->Value();
		1681	+ if ( XMLUtil::ToBool( t, bval ) ) {
		1682	+ return XML_SUCCESS;
		1683	+ }
		1684	+ return XML_CAN_NOT_CONVERT_TEXT;
		1685	+ }
		1686	+ return XML_NO_TEXT_NODE;
		1687	+}
		1688	+
		1689	+
		1690	+XMLError XMLElement::QueryDoubleText( double* dval ) const
		1691	+{
		1692	+ if ( FirstChild() && FirstChild()->ToText() ) {
		1693	+ const char* t = FirstChild()->Value();
		1694	+ if ( XMLUtil::ToDouble( t, dval ) ) {
		1695	+ return XML_SUCCESS;
		1696	+ }
		1697	+ return XML_CAN_NOT_CONVERT_TEXT;
		1698	+ }
		1699	+ return XML_NO_TEXT_NODE;
		1700	+}
		1701	+
		1702	+
		1703	+XMLError XMLElement::QueryFloatText( float* fval ) const
		1704	+{
		1705	+ if ( FirstChild() && FirstChild()->ToText() ) {
		1706	+ const char* t = FirstChild()->Value();
		1707	+ if ( XMLUtil::ToFloat( t, fval ) ) {
		1708	+ return XML_SUCCESS;
		1709	+ }
		1710	+ return XML_CAN_NOT_CONVERT_TEXT;
		1711	+ }
		1712	+ return XML_NO_TEXT_NODE;
		1713	+}
		1714	+
		1715	+int XMLElement::IntText(int defaultValue) const
		1716	+{
		1717	+ int i = defaultValue;
		1718	+ QueryIntText(&i);
		1719	+ return i;
		1720	+}
		1721	+
		1722	+unsigned XMLElement::UnsignedText(unsigned defaultValue) const
		1723	+{
		1724	+ unsigned i = defaultValue;
		1725	+ QueryUnsignedText(&i);
		1726	+ return i;
		1727	+}
		1728	+
		1729	+int64_t XMLElement::Int64Text(int64_t defaultValue) const
		1730	+{
		1731	+ int64_t i = defaultValue;
		1732	+ QueryInt64Text(&i);
		1733	+ return i;
		1734	+}
		1735	+
		1736	+bool XMLElement::BoolText(bool defaultValue) const
		1737	+{
		1738	+ bool b = defaultValue;
		1739	+ QueryBoolText(&b);
		1740	+ return b;
		1741	+}
		1742	+
		1743	+double XMLElement::DoubleText(double defaultValue) const
		1744	+{
		1745	+ double d = defaultValue;
		1746	+ QueryDoubleText(&d);
		1747	+ return d;
		1748	+}
		1749	+
		1750	+float XMLElement::FloatText(float defaultValue) const
		1751	+{
		1752	+ float f = defaultValue;
		1753	+ QueryFloatText(&f);
		1754	+ return f;
		1755	+}
		1756	+
		1757	+
		1758	+XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
		1759	+{
		1760	+ XMLAttribute* last = 0;
		1761	+ XMLAttribute* attrib = 0;
		1762	+ for( attrib = _rootAttribute;
		1763	+ attrib;
		1764	+ last = attrib, attrib = attrib->_next ) {
		1765	+ if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
		1766	+ break;
		1767	+ }
		1768	+ }
		1769	+ if ( !attrib ) {
		1770	+ attrib = CreateAttribute();
		1771	+ TIXMLASSERT( attrib );
		1772	+ if ( last ) {
		1773	+ TIXMLASSERT( last->_next == 0 );
		1774	+ last->_next = attrib;
		1775	+ }
		1776	+ else {
		1777	+ TIXMLASSERT( _rootAttribute == 0 );
		1778	+ _rootAttribute = attrib;
		1779	+ }
		1780	+ attrib->SetName( name );
		1781	+ }
		1782	+ return attrib;
		1783	+}
		1784	+
		1785	+
		1786	+void XMLElement::DeleteAttribute( const char* name )
		1787	+{
		1788	+ XMLAttribute* prev = 0;
		1789	+ for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
		1790	+ if ( XMLUtil::StringEqual( name, a->Name() ) ) {
		1791	+ if ( prev ) {
		1792	+ prev->_next = a->_next;
		1793	+ }
		1794	+ else {
		1795	+ _rootAttribute = a->_next;
		1796	+ }
		1797	+ DeleteAttribute( a );
		1798	+ break;
		1799	+ }
		1800	+ prev = a;
		1801	+ }
		1802	+}
		1803	+
		1804	+
		1805	+char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
		1806	+{
		1807	+ XMLAttribute* prevAttribute = 0;
		1808	+
		1809	+ // Read the attributes.
		1810	+ while( p ) {
		1811	+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
		1812	+ if ( !(*p) ) {
		1813	+ _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name() );
		1814	+ return 0;
		1815	+ }
		1816	+
		1817	+ // attribute.
		1818	+ if (XMLUtil::IsNameStartChar( *p ) ) {
		1819	+ XMLAttribute* attrib = CreateAttribute();
		1820	+ TIXMLASSERT( attrib );
		1821	+ attrib->_parseLineNum = _document->_parseCurLineNum;
		1822	+
		1823	+ int attrLineNum = attrib->_parseLineNum;
		1824	+
		1825	+ p = attrib->ParseDeep( p, _document->ProcessEntities(), curLineNumPtr );
		1826	+ if ( !p \|\| Attribute( attrib->Name() ) ) {
		1827	+ DeleteAttribute( attrib );
		1828	+ _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name() );
		1829	+ return 0;
		1830	+ }
		1831	+ // There is a minor bug here: if the attribute in the source xml
		1832	+ // document is duplicated, it will not be detected and the
		1833	+ // attribute will be doubly added. However, tracking the 'prevAttribute'
		1834	+ // avoids re-scanning the attribute list. Preferring performance for
		1835	+ // now, may reconsider in the future.
		1836	+ if ( prevAttribute ) {
		1837	+ TIXMLASSERT( prevAttribute->_next == 0 );
		1838	+ prevAttribute->_next = attrib;
		1839	+ }
		1840	+ else {
		1841	+ TIXMLASSERT( _rootAttribute == 0 );
		1842	+ _rootAttribute = attrib;
		1843	+ }
		1844	+ prevAttribute = attrib;
		1845	+ }
		1846	+ // end of the tag
		1847	+ else if ( *p == '>' ) {
		1848	+ ++p;
		1849	+ break;
		1850	+ }
		1851	+ // end of the tag
		1852	+ else if ( p == '/' && (p+1) == '>' ) {
		1853	+ _closingType = CLOSED;
		1854	+ return p+2; // done; sealed element.
		1855	+ }
		1856	+ else {
		1857	+ _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0 );
		1858	+ return 0;
		1859	+ }
		1860	+ }
		1861	+ return p;
		1862	+}
		1863	+
		1864	+void XMLElement::DeleteAttribute( XMLAttribute* attribute )
		1865	+{
		1866	+ if ( attribute == 0 ) {
		1867	+ return;
		1868	+ }
		1869	+ MemPool* pool = attribute->_memPool;
		1870	+ attribute->~XMLAttribute();
		1871	+ pool->Free( attribute );
		1872	+}
		1873	+
		1874	+XMLAttribute* XMLElement::CreateAttribute()
		1875	+{
		1876	+ TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
		1877	+ XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
		1878	+ TIXMLASSERT( attrib );
		1879	+ attrib->_memPool = &_document->_attributePool;
		1880	+ attrib->_memPool->SetTracked();
		1881	+ return attrib;
		1882	+}
		1883	+
		1884	+//
		1885	+// <ele></ele>
		1886	+// <ele>foo<b>bar</b></ele>
		1887	+//
		1888	+char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
		1889	+{
		1890	+ // Read the element name.
		1891	+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
		1892	+
		1893	+ // The closing element is the </element> form. It is
		1894	+ // parsed just like a regular element then deleted from
		1895	+ // the DOM.
		1896	+ if ( *p == '/' ) {
		1897	+ _closingType = CLOSING;
		1898	+ ++p;
		1899	+ }
		1900	+
		1901	+ p = _value.ParseName( p );
		1902	+ if ( _value.Empty() ) {
		1903	+ return 0;
		1904	+ }
		1905	+
		1906	+ p = ParseAttributes( p, curLineNumPtr );
		1907	+ if ( !p \|\| !*p \|\| _closingType != OPEN ) {
		1908	+ return p;
		1909	+ }
		1910	+
		1911	+ p = XMLNode::ParseDeep( p, parentEndTag, curLineNumPtr );
		1912	+ return p;
		1913	+}
		1914	+
		1915	+
		1916	+
		1917	+XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
		1918	+{
		1919	+ if ( !doc ) {
		1920	+ doc = _document;
		1921	+ }
		1922	+ XMLElement* element = doc->NewElement( Value() ); // fixme: this will always allocate memory. Intern?
		1923	+ for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
		1924	+ element->SetAttribute( a->Name(), a->Value() ); // fixme: this will always allocate memory. Intern?
		1925	+ }
		1926	+ return element;
		1927	+}
		1928	+
		1929	+
		1930	+bool XMLElement::ShallowEqual( const XMLNode* compare ) const
		1931	+{
		1932	+ TIXMLASSERT( compare );
		1933	+ const XMLElement* other = compare->ToElement();
		1934	+ if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {
		1935	+
		1936	+ const XMLAttribute* a=FirstAttribute();
		1937	+ const XMLAttribute* b=other->FirstAttribute();
		1938	+
		1939	+ while ( a && b ) {
		1940	+ if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
		1941	+ return false;
		1942	+ }
		1943	+ a = a->Next();
		1944	+ b = b->Next();
		1945	+ }
		1946	+ if ( a \|\| b ) {
		1947	+ // different count
		1948	+ return false;
		1949	+ }
		1950	+ return true;
		1951	+ }
		1952	+ return false;
		1953	+}
		1954	+
		1955	+
		1956	+bool XMLElement::Accept( XMLVisitor* visitor ) const
		1957	+{
		1958	+ TIXMLASSERT( visitor );
		1959	+ if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
		1960	+ for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
		1961	+ if ( !node->Accept( visitor ) ) {
		1962	+ break;
		1963	+ }
		1964	+ }
		1965	+ }
		1966	+ return visitor->VisitExit( *this );
		1967	+}
		1968	+
		1969	+
		1970	+// --------- XMLDocument ----------- //
		1971	+
		1972	+// Warning: List must match 'enum XMLError'
		1973	+const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
		1974	+ "XML_SUCCESS",
		1975	+ "XML_NO_ATTRIBUTE",
		1976	+ "XML_WRONG_ATTRIBUTE_TYPE",
		1977	+ "XML_ERROR_FILE_NOT_FOUND",
		1978	+ "XML_ERROR_FILE_COULD_NOT_BE_OPENED",
		1979	+ "XML_ERROR_FILE_READ_ERROR",
		1980	+ "UNUSED_XML_ERROR_ELEMENT_MISMATCH",
		1981	+ "XML_ERROR_PARSING_ELEMENT",
		1982	+ "XML_ERROR_PARSING_ATTRIBUTE",
		1983	+ "UNUSED_XML_ERROR_IDENTIFYING_TAG",
		1984	+ "XML_ERROR_PARSING_TEXT",
		1985	+ "XML_ERROR_PARSING_CDATA",
		1986	+ "XML_ERROR_PARSING_COMMENT",
		1987	+ "XML_ERROR_PARSING_DECLARATION",
		1988	+ "XML_ERROR_PARSING_UNKNOWN",
		1989	+ "XML_ERROR_EMPTY_DOCUMENT",
		1990	+ "XML_ERROR_MISMATCHED_ELEMENT",
		1991	+ "XML_ERROR_PARSING",
		1992	+ "XML_CAN_NOT_CONVERT_TEXT",
		1993	+ "XML_NO_TEXT_NODE",
		1994	+ "XML_ELEMENT_DEPTH_EXCEEDED"
		1995	+};
		1996	+
		1997	+
		1998	+XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
		1999	+ XMLNode( 0 ),
		2000	+ _writeBOM( false ),
		2001	+ _processEntities( processEntities ),
		2002	+ _errorID(XML_SUCCESS),
		2003	+ _whitespaceMode( whitespaceMode ),
		2004	+ _errorStr(),
		2005	+ _errorLineNum( 0 ),
		2006	+ _charBuffer( 0 ),
		2007	+ _parseCurLineNum( 0 ),
		2008	+ _parsingDepth(0),
		2009	+ _unlinked(),
		2010	+ _elementPool(),
		2011	+ _attributePool(),
		2012	+ _textPool(),
		2013	+ _commentPool()
		2014	+{
		2015	+ // avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)
		2016	+ _document = this;
		2017	+}
		2018	+
		2019	+
		2020	+XMLDocument::~XMLDocument()
		2021	+{
		2022	+ Clear();
		2023	+}
		2024	+
		2025	+
		2026	+void XMLDocument::MarkInUse(XMLNode* node)
		2027	+{
		2028	+ TIXMLASSERT(node);
		2029	+ TIXMLASSERT(node->_parent == 0);
		2030	+
		2031	+ for (int i = 0; i < _unlinked.Size(); ++i) {
		2032	+ if (node == _unlinked[i]) {
		2033	+ _unlinked.SwapRemove(i);
		2034	+ break;
		2035	+ }
		2036	+ }
		2037	+}
		2038	+
		2039	+void XMLDocument::Clear()
		2040	+{
		2041	+ DeleteChildren();
		2042	+ while( _unlinked.Size()) {
		2043	+ DeleteNode(_unlinked[0]); // Will remove from _unlinked as part of delete.
		2044	+ }
		2045	+
		2046	+#ifdef TINYXML2_DEBUG
		2047	+ const bool hadError = Error();
		2048	+#endif
		2049	+ ClearError();
		2050	+
		2051	+ delete [] _charBuffer;
		2052	+ _charBuffer = 0;
		2053	+ _parsingDepth = 0;
		2054	+
		2055	+#if 0
		2056	+ _textPool.Trace( "text" );
		2057	+ _elementPool.Trace( "element" );
		2058	+ _commentPool.Trace( "comment" );
		2059	+ _attributePool.Trace( "attribute" );
		2060	+#endif
		2061	+
		2062	+#ifdef TINYXML2_DEBUG
		2063	+ if ( !hadError ) {
		2064	+ TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );
		2065	+ TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
		2066	+ TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );
		2067	+ TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );
		2068	+ }
		2069	+#endif
		2070	+}
		2071	+
		2072	+
		2073	+void XMLDocument::DeepCopy(XMLDocument* target) const
		2074	+{
		2075	+ TIXMLASSERT(target);
		2076	+ if (target == this) {
		2077	+ return; // technically success - a no-op.
		2078	+ }
		2079	+
		2080	+ target->Clear();
		2081	+ for (const XMLNode* node = this->FirstChild(); node; node = node->NextSibling()) {
		2082	+ target->InsertEndChild(node->DeepClone(target));
		2083	+ }
		2084	+}
		2085	+
		2086	+XMLElement* XMLDocument::NewElement( const char* name )
		2087	+{
		2088	+ XMLElement* ele = CreateUnlinkedNode<XMLElement>( _elementPool );
		2089	+ ele->SetName( name );
		2090	+ return ele;
		2091	+}
		2092	+
		2093	+
		2094	+XMLComment* XMLDocument::NewComment( const char* str )
		2095	+{
		2096	+ XMLComment* comment = CreateUnlinkedNode<XMLComment>( _commentPool );
		2097	+ comment->SetValue( str );
		2098	+ return comment;
		2099	+}
		2100	+
		2101	+
		2102	+XMLText* XMLDocument::NewText( const char* str )
		2103	+{
		2104	+ XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
		2105	+ text->SetValue( str );
		2106	+ return text;
		2107	+}
		2108	+
		2109	+
		2110	+XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
		2111	+{
		2112	+ XMLDeclaration* dec = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
		2113	+ dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
		2114	+ return dec;
		2115	+}
		2116	+
		2117	+
		2118	+XMLUnknown* XMLDocument::NewUnknown( const char* str )
		2119	+{
		2120	+ XMLUnknown* unk = CreateUnlinkedNode<XMLUnknown>( _commentPool );
		2121	+ unk->SetValue( str );
		2122	+ return unk;
		2123	+}
		2124	+
		2125	+static FILE* callfopen( const char* filepath, const char* mode )
		2126	+{
		2127	+ TIXMLASSERT( filepath );
		2128	+ TIXMLASSERT( mode );
		2129	+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
		2130	+ FILE* fp = 0;
		2131	+ errno_t err = fopen_s( &fp, filepath, mode );
		2132	+ if ( err ) {
		2133	+ return 0;
		2134	+ }
		2135	+#else
		2136	+ FILE* fp = fopen( filepath, mode );
		2137	+#endif
		2138	+ return fp;
		2139	+}
		2140	+
		2141	+void XMLDocument::DeleteNode( XMLNode* node ) {
		2142	+ TIXMLASSERT( node );
		2143	+ TIXMLASSERT(node->_document == this );
		2144	+ if (node->_parent) {
		2145	+ node->_parent->DeleteChild( node );
		2146	+ }
		2147	+ else {
		2148	+ // Isn't in the tree.
		2149	+ // Use the parent delete.
		2150	+ // Also, we need to mark it tracked: we 'know'
		2151	+ // it was never used.
		2152	+ node->_memPool->SetTracked();
		2153	+ // Call the static XMLNode version:
		2154	+ XMLNode::DeleteNode(node);
		2155	+ }
		2156	+}
		2157	+
		2158	+
		2159	+XMLError XMLDocument::LoadFile( const char* filename )
		2160	+{
		2161	+ if ( !filename ) {
		2162	+ TIXMLASSERT( false );
		2163	+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
		2164	+ return _errorID;
		2165	+ }
		2166	+
		2167	+ Clear();
		2168	+ FILE* fp = callfopen( filename, "rb" );
		2169	+ if ( !fp ) {
		2170	+ SetError( XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename );
		2171	+ return _errorID;
		2172	+ }
		2173	+ LoadFile( fp );
		2174	+ fclose( fp );
		2175	+ return _errorID;
		2176	+}
		2177	+
		2178	+// This is likely overengineered template art to have a check that unsigned long value incremented
		2179	+// by one still fits into size_t. If size_t type is larger than unsigned long type
		2180	+// (x86_64-w64-mingw32 target) then the check is redundant and gcc and clang emit
		2181	+// -Wtype-limits warning. This piece makes the compiler select code with a check when a check
		2182	+// is useful and code with no check when a check is redundant depending on how size_t and unsigned long
		2183	+// types sizes relate to each other.
		2184	+template
		2185	+<bool = (sizeof(unsigned long) >= sizeof(size_t))>
		2186	+struct LongFitsIntoSizeTMinusOne {
		2187	+ static bool Fits( unsigned long value )
		2188	+ {
		2189	+ return value < (size_t)-1;
		2190	+ }
		2191	+};
		2192	+
		2193	+template <>
		2194	+struct LongFitsIntoSizeTMinusOne<false> {
		2195	+ static bool Fits( unsigned long )
		2196	+ {
		2197	+ return true;
		2198	+ }
		2199	+};
		2200	+
		2201	+XMLError XMLDocument::LoadFile( FILE* fp )
		2202	+{
		2203	+ Clear();
		2204	+
		2205	+ fseek( fp, 0, SEEK_SET );
		2206	+ if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
		2207	+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
		2208	+ return _errorID;
		2209	+ }
		2210	+
		2211	+ fseek( fp, 0, SEEK_END );
		2212	+ const long filelength = ftell( fp );
		2213	+ fseek( fp, 0, SEEK_SET );
		2214	+ if ( filelength == -1L ) {
		2215	+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
		2216	+ return _errorID;
		2217	+ }
		2218	+ TIXMLASSERT( filelength >= 0 );
		2219	+
		2220	+ if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {
		2221	+ // Cannot handle files which won't fit in buffer together with null terminator
		2222	+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
		2223	+ return _errorID;
		2224	+ }
		2225	+
		2226	+ if ( filelength == 0 ) {
		2227	+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
		2228	+ return _errorID;
		2229	+ }
		2230	+
		2231	+ const size_t size = filelength;
		2232	+ TIXMLASSERT( _charBuffer == 0 );
		2233	+ _charBuffer = new char[size+1];
		2234	+ size_t read = fread( _charBuffer, 1, size, fp );
		2235	+ if ( read != size ) {
		2236	+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
		2237	+ return _errorID;
		2238	+ }
		2239	+
		2240	+ _charBuffer[size] = 0;
		2241	+
		2242	+ Parse();
		2243	+ return _errorID;
		2244	+}
		2245	+
		2246	+
		2247	+XMLError XMLDocument::SaveFile( const char* filename, bool compact )
		2248	+{
		2249	+ if ( !filename ) {
		2250	+ TIXMLASSERT( false );
		2251	+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
		2252	+ return _errorID;
		2253	+ }
		2254	+
		2255	+ FILE* fp = callfopen( filename, "w" );
		2256	+ if ( !fp ) {
		2257	+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename );
		2258	+ return _errorID;
		2259	+ }
		2260	+ SaveFile(fp, compact);
		2261	+ fclose( fp );
		2262	+ return _errorID;
		2263	+}
		2264	+
		2265	+
		2266	+XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
		2267	+{
		2268	+ // Clear any error from the last save, otherwise it will get reported
		2269	+ // for this call.
		2270	+ ClearError();
		2271	+ XMLPrinter stream( fp, compact );
		2272	+ Print( &stream );
		2273	+ return _errorID;
		2274	+}
		2275	+
		2276	+
		2277	+XMLError XMLDocument::Parse( const char* p, size_t len )
		2278	+{
		2279	+ Clear();
		2280	+
		2281	+ if ( len == 0 \|\| !p \|\| !*p ) {
		2282	+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
		2283	+ return _errorID;
		2284	+ }
		2285	+ if ( len == (size_t)(-1) ) {
		2286	+ len = strlen( p );
		2287	+ }
		2288	+ TIXMLASSERT( _charBuffer == 0 );
		2289	+ _charBuffer = new char[ len+1 ];
		2290	+ memcpy( _charBuffer, p, len );
		2291	+ _charBuffer[len] = 0;
		2292	+
		2293	+ Parse();
		2294	+ if ( Error() ) {
		2295	+ // clean up now essentially dangling memory.
		2296	+ // and the parse fail can put objects in the
		2297	+ // pools that are dead and inaccessible.
		2298	+ DeleteChildren();
		2299	+ _elementPool.Clear();
		2300	+ _attributePool.Clear();
		2301	+ _textPool.Clear();
		2302	+ _commentPool.Clear();
		2303	+ }
		2304	+ return _errorID;
		2305	+}
		2306	+
		2307	+
		2308	+void XMLDocument::Print( XMLPrinter* streamer ) const
		2309	+{
		2310	+ if ( streamer ) {
		2311	+ Accept( streamer );
		2312	+ }
		2313	+ else {
		2314	+ XMLPrinter stdoutStreamer( stdout );
		2315	+ Accept( &stdoutStreamer );
		2316	+ }
		2317	+}
		2318	+
		2319	+
		2320	+void XMLDocument::SetError( XMLError error, int lineNum, const char* format, ... )
		2321	+{
		2322	+ TIXMLASSERT( error >= 0 && error < XML_ERROR_COUNT );
		2323	+ _errorID = error;
		2324	+ _errorLineNum = lineNum;
		2325	+ _errorStr.Reset();
		2326	+
		2327	+ size_t BUFFER_SIZE = 1000;
		2328	+ char* buffer = new char[BUFFER_SIZE];
		2329	+
		2330	+ TIXML_SNPRINTF(buffer, BUFFER_SIZE, "Error=%s ErrorID=%d (0x%x) Line number=%d", ErrorIDToName(error), int(error), int(error), lineNum);
		2331	+
		2332	+ if (format) {
		2333	+ size_t len = strlen(buffer);
		2334	+ TIXML_SNPRINTF(buffer + len, BUFFER_SIZE - len, ": ");
		2335	+ len = strlen(buffer);
		2336	+
		2337	+ va_list va;
		2338	+ va_start(va, format);
		2339	+ TIXML_VSNPRINTF(buffer + len, BUFFER_SIZE - len, format, va);
		2340	+ va_end(va);
		2341	+ }
		2342	+ _errorStr.SetStr(buffer);
		2343	+ delete[] buffer;
		2344	+}
		2345	+
		2346	+
		2347	+/static/ const char* XMLDocument::ErrorIDToName(XMLError errorID)
		2348	+{
		2349	+ TIXMLASSERT( errorID >= 0 && errorID < XML_ERROR_COUNT );
		2350	+ const char* errorName = _errorNames[errorID];
		2351	+ TIXMLASSERT( errorName && errorName[0] );
		2352	+ return errorName;
		2353	+}
		2354	+
		2355	+const char* XMLDocument::ErrorStr() const
		2356	+{
		2357	+ return _errorStr.Empty() ? "" : _errorStr.GetStr();
		2358	+}
		2359	+
		2360	+
		2361	+void XMLDocument::PrintError() const
		2362	+{
		2363	+ printf("%s\n", ErrorStr());
		2364	+}
		2365	+
		2366	+const char* XMLDocument::ErrorName() const
		2367	+{
		2368	+ return ErrorIDToName(_errorID);
		2369	+}
		2370	+
		2371	+void XMLDocument::Parse()
		2372	+{
		2373	+ TIXMLASSERT( NoChildren() ); // Clear() must have been called previously
		2374	+ TIXMLASSERT( _charBuffer );
		2375	+ _parseCurLineNum = 1;
		2376	+ _parseLineNum = 1;
		2377	+ char* p = _charBuffer;
		2378	+ p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
		2379	+ p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
		2380	+ if ( !*p ) {
		2381	+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
		2382	+ return;
		2383	+ }
		2384	+ ParseDeep(p, 0, &_parseCurLineNum );
		2385	+}
		2386	+
		2387	+void XMLDocument::PushDepth()
		2388	+{
		2389	+ _parsingDepth++;
		2390	+ if (_parsingDepth == TINYXML2_MAX_ELEMENT_DEPTH) {
		2391	+ SetError(XML_ELEMENT_DEPTH_EXCEEDED, _parseCurLineNum, "Element nesting is too deep." );
		2392	+ }
		2393	+}
		2394	+
		2395	+void XMLDocument::PopDepth()
		2396	+{
		2397	+ TIXMLASSERT(_parsingDepth > 0);
		2398	+ --_parsingDepth;
		2399	+}
		2400	+
		2401	+XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
		2402	+ _elementJustOpened( false ),
		2403	+ _stack(),
		2404	+ _firstElement( true ),
		2405	+ _fp( file ),
		2406	+ _depth( depth ),
		2407	+ _textDepth( -1 ),
		2408	+ _processEntities( true ),
		2409	+ _compactMode( compact ),
		2410	+ _buffer()
		2411	+{
		2412	+ for( int i=0; i<ENTITY_RANGE; ++i ) {
		2413	+ _entityFlag[i] = false;
		2414	+ _restrictedEntityFlag[i] = false;
		2415	+ }
		2416	+ for( int i=0; i<NUM_ENTITIES; ++i ) {
		2417	+ const char entityValue = entities[i].value;
		2418	+ const unsigned char flagIndex = (unsigned char)entityValue;
		2419	+ TIXMLASSERT( flagIndex < ENTITY_RANGE );
		2420	+ _entityFlag[flagIndex] = true;
		2421	+ }
		2422	+ _restrictedEntityFlag[(unsigned char)'&'] = true;
		2423	+ _restrictedEntityFlag[(unsigned char)'<'] = true;
		2424	+ _restrictedEntityFlag[(unsigned char)'>'] = true; // not required, but consistency is nice
		2425	+ _buffer.Push( 0 );
		2426	+}
		2427	+
		2428	+
		2429	+void XMLPrinter::Print( const char* format, ... )
		2430	+{
		2431	+ va_list va;
		2432	+ va_start( va, format );
		2433	+
		2434	+ if ( _fp ) {
		2435	+ vfprintf( _fp, format, va );
		2436	+ }
		2437	+ else {
		2438	+ const int len = TIXML_VSCPRINTF( format, va );
		2439	+ // Close out and re-start the va-args
		2440	+ va_end( va );
		2441	+ TIXMLASSERT( len >= 0 );
		2442	+ va_start( va, format );
		2443	+ TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
		2444	+ char* p = _buffer.PushArr( len ) - 1; // back up over the null terminator.
		2445	+ TIXML_VSNPRINTF( p, len+1, format, va );
		2446	+ }
		2447	+ va_end( va );
		2448	+}
		2449	+
		2450	+
		2451	+void XMLPrinter::Write( const char* data, size_t size )
		2452	+{
		2453	+ if ( _fp ) {
		2454	+ fwrite ( data , sizeof(char), size, _fp);
		2455	+ }
		2456	+ else {
		2457	+ char* p = _buffer.PushArr( static_cast<int>(size) ) - 1; // back up over the null terminator.
		2458	+ memcpy( p, data, size );
		2459	+ p[size] = 0;
		2460	+ }
		2461	+}
		2462	+
		2463	+
		2464	+void XMLPrinter::Putc( char ch )
		2465	+{
		2466	+ if ( _fp ) {
		2467	+ fputc ( ch, _fp);
		2468	+ }
		2469	+ else {
		2470	+ char* p = _buffer.PushArr( sizeof(char) ) - 1; // back up over the null terminator.
		2471	+ p[0] = ch;
		2472	+ p[1] = 0;
		2473	+ }
		2474	+}
		2475	+
		2476	+
		2477	+void XMLPrinter::PrintSpace( int depth )
		2478	+{
		2479	+ for( int i=0; i<depth; ++i ) {
		2480	+ Write( " " );
		2481	+ }
		2482	+}
		2483	+
		2484	+
		2485	+void XMLPrinter::PrintString( const char* p, bool restricted )
		2486	+{
		2487	+ // Look for runs of bytes between entities to print.
		2488	+ const char* q = p;
		2489	+
		2490	+ if ( _processEntities ) {
		2491	+ const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
		2492	+ while ( *q ) {
		2493	+ TIXMLASSERT( p <= q );
		2494	+ // Remember, char is sometimes signed. (How many times has that bitten me?)
		2495	+ if ( q > 0 && q < ENTITY_RANGE ) {
		2496	+ // Check for entities. If one is found, flush
		2497	+ // the stream up until the entity, write the
		2498	+ // entity, and keep looking.
		2499	+ if ( flag[(unsigned char)(*q)] ) {
		2500	+ while ( p < q ) {
		2501	+ const size_t delta = q - p;
		2502	+ const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
		2503	+ Write( p, toPrint );
		2504	+ p += toPrint;
		2505	+ }
		2506	+ bool entityPatternPrinted = false;
		2507	+ for( int i=0; i<NUM_ENTITIES; ++i ) {
		2508	+ if ( entities[i].value == *q ) {
		2509	+ Putc( '&' );
		2510	+ Write( entities[i].pattern, entities[i].length );
		2511	+ Putc( ';' );
		2512	+ entityPatternPrinted = true;
		2513	+ break;
		2514	+ }
		2515	+ }
		2516	+ if ( !entityPatternPrinted ) {
		2517	+ // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
		2518	+ TIXMLASSERT( false );
		2519	+ }
		2520	+ ++p;
		2521	+ }
		2522	+ }
		2523	+ ++q;
		2524	+ TIXMLASSERT( p <= q );
		2525	+ }
		2526	+ }
		2527	+ // Flush the remaining string. This will be the entire
		2528	+ // string if an entity wasn't found.
		2529	+ TIXMLASSERT( p <= q );
		2530	+ if ( !_processEntities \|\| ( p < q ) ) {
		2531	+ const size_t delta = q - p;
		2532	+ const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
		2533	+ Write( p, toPrint );
		2534	+ }
		2535	+}
		2536	+
		2537	+
		2538	+void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
		2539	+{
		2540	+ if ( writeBOM ) {
		2541	+ static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
		2542	+ Write( reinterpret_cast< const char* >( bom ) );
		2543	+ }
		2544	+ if ( writeDec ) {
		2545	+ PushDeclaration( "xml version=\"1.0\"" );
		2546	+ }
		2547	+}
		2548	+
		2549	+
		2550	+void XMLPrinter::OpenElement( const char* name, bool compactMode )
		2551	+{
		2552	+ SealElementIfJustOpened();
		2553	+ _stack.Push( name );
		2554	+
		2555	+ if ( _textDepth < 0 && !_firstElement && !compactMode ) {
		2556	+ Putc( '\n' );
		2557	+ }
		2558	+ if ( !compactMode ) {
		2559	+ PrintSpace( _depth );
		2560	+ }
		2561	+
		2562	+ Write ( "<" );
		2563	+ Write ( name );
		2564	+
		2565	+ _elementJustOpened = true;
		2566	+ _firstElement = false;
		2567	+ ++_depth;
		2568	+}
		2569	+
		2570	+
		2571	+void XMLPrinter::PushAttribute( const char* name, const char* value )
		2572	+{
		2573	+ TIXMLASSERT( _elementJustOpened );
		2574	+ Putc ( ' ' );
		2575	+ Write( name );
		2576	+ Write( "=\"" );
		2577	+ PrintString( value, false );
		2578	+ Putc ( '\"' );
		2579	+}
		2580	+
		2581	+
		2582	+void XMLPrinter::PushAttribute( const char* name, int v )
		2583	+{
		2584	+ char buf[BUF_SIZE];
		2585	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		2586	+ PushAttribute( name, buf );
		2587	+}
		2588	+
		2589	+
		2590	+void XMLPrinter::PushAttribute( const char* name, unsigned v )
		2591	+{
		2592	+ char buf[BUF_SIZE];
		2593	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		2594	+ PushAttribute( name, buf );
		2595	+}
		2596	+
		2597	+
		2598	+void XMLPrinter::PushAttribute(const char* name, int64_t v)
		2599	+{
		2600	+ char buf[BUF_SIZE];
		2601	+ XMLUtil::ToStr(v, buf, BUF_SIZE);
		2602	+ PushAttribute(name, buf);
		2603	+}
		2604	+
		2605	+
		2606	+void XMLPrinter::PushAttribute( const char* name, bool v )
		2607	+{
		2608	+ char buf[BUF_SIZE];
		2609	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		2610	+ PushAttribute( name, buf );
		2611	+}
		2612	+
		2613	+
		2614	+void XMLPrinter::PushAttribute( const char* name, double v )
		2615	+{
		2616	+ char buf[BUF_SIZE];
		2617	+ XMLUtil::ToStr( v, buf, BUF_SIZE );
		2618	+ PushAttribute( name, buf );
		2619	+}
		2620	+
		2621	+
		2622	+void XMLPrinter::CloseElement( bool compactMode )
		2623	+{
		2624	+ --_depth;
		2625	+ const char* name = _stack.Pop();
		2626	+
		2627	+ if ( _elementJustOpened ) {
		2628	+ Write( "/>" );
		2629	+ }
		2630	+ else {
		2631	+ if ( _textDepth < 0 && !compactMode) {
		2632	+ Putc( '\n' );
		2633	+ PrintSpace( _depth );
		2634	+ }
		2635	+ Write ( "</" );
		2636	+ Write ( name );
		2637	+ Write ( ">" );
		2638	+ }
		2639	+
		2640	+ if ( _textDepth == _depth ) {
		2641	+ _textDepth = -1;
		2642	+ }
		2643	+ if ( _depth == 0 && !compactMode) {
		2644	+ Putc( '\n' );
		2645	+ }
		2646	+ _elementJustOpened = false;
		2647	+}
		2648	+
		2649	+
		2650	+void XMLPrinter::SealElementIfJustOpened()
		2651	+{
		2652	+ if ( !_elementJustOpened ) {
		2653	+ return;
		2654	+ }
		2655	+ _elementJustOpened = false;
		2656	+ Putc( '>' );
		2657	+}
		2658	+
		2659	+
		2660	+void XMLPrinter::PushText( const char* text, bool cdata )
		2661	+{
		2662	+ _textDepth = _depth-1;
		2663	+
		2664	+ SealElementIfJustOpened();
		2665	+ if ( cdata ) {
		2666	+ Write( "<![CDATA[" );
		2667	+ Write( text );
		2668	+ Write( "]]>" );
		2669	+ }
		2670	+ else {
		2671	+ PrintString( text, true );
		2672	+ }
		2673	+}
		2674	+
		2675	+void XMLPrinter::PushText( int64_t value )
		2676	+{
		2677	+ char buf[BUF_SIZE];
		2678	+ XMLUtil::ToStr( value, buf, BUF_SIZE );
		2679	+ PushText( buf, false );
		2680	+}
		2681	+
		2682	+void XMLPrinter::PushText( int value )
		2683	+{
		2684	+ char buf[BUF_SIZE];
		2685	+ XMLUtil::ToStr( value, buf, BUF_SIZE );
		2686	+ PushText( buf, false );
		2687	+}
		2688	+
		2689	+
		2690	+void XMLPrinter::PushText( unsigned value )
		2691	+{
		2692	+ char buf[BUF_SIZE];
		2693	+ XMLUtil::ToStr( value, buf, BUF_SIZE );
		2694	+ PushText( buf, false );
		2695	+}
		2696	+
		2697	+
		2698	+void XMLPrinter::PushText( bool value )
		2699	+{
		2700	+ char buf[BUF_SIZE];
		2701	+ XMLUtil::ToStr( value, buf, BUF_SIZE );
		2702	+ PushText( buf, false );
		2703	+}
		2704	+
		2705	+
		2706	+void XMLPrinter::PushText( float value )
		2707	+{
		2708	+ char buf[BUF_SIZE];
		2709	+ XMLUtil::ToStr( value, buf, BUF_SIZE );
		2710	+ PushText( buf, false );
		2711	+}
		2712	+
		2713	+
		2714	+void XMLPrinter::PushText( double value )
		2715	+{
		2716	+ char buf[BUF_SIZE];
		2717	+ XMLUtil::ToStr( value, buf, BUF_SIZE );
		2718	+ PushText( buf, false );
		2719	+}
		2720	+
		2721	+
		2722	+void XMLPrinter::PushComment( const char* comment )
		2723	+{
		2724	+ SealElementIfJustOpened();
		2725	+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {
		2726	+ Putc( '\n' );
		2727	+ PrintSpace( _depth );
		2728	+ }
		2729	+ _firstElement = false;
		2730	+
		2731	+ Write( "<!--" );
		2732	+ Write( comment );
		2733	+ Write( "-->" );
		2734	+}
		2735	+
		2736	+
		2737	+void XMLPrinter::PushDeclaration( const char* value )
		2738	+{
		2739	+ SealElementIfJustOpened();
		2740	+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {
		2741	+ Putc( '\n' );
		2742	+ PrintSpace( _depth );
		2743	+ }
		2744	+ _firstElement = false;
		2745	+
		2746	+ Write( "<?" );
		2747	+ Write( value );
		2748	+ Write( "?>" );
		2749	+}
		2750	+
		2751	+
		2752	+void XMLPrinter::PushUnknown( const char* value )
		2753	+{
		2754	+ SealElementIfJustOpened();
		2755	+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {
		2756	+ Putc( '\n' );
		2757	+ PrintSpace( _depth );
		2758	+ }
		2759	+ _firstElement = false;
		2760	+
		2761	+ Write( "<!" );
		2762	+ Write( value );
		2763	+ Putc( '>' );
		2764	+}
		2765	+
		2766	+
		2767	+bool XMLPrinter::VisitEnter( const XMLDocument& doc )
		2768	+{
		2769	+ _processEntities = doc.ProcessEntities();
		2770	+ if ( doc.HasBOM() ) {
		2771	+ PushHeader( true, false );
		2772	+ }
		2773	+ return true;
		2774	+}
		2775	+
		2776	+
		2777	+bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
		2778	+{
		2779	+ const XMLElement* parentElem = 0;
		2780	+ if ( element.Parent() ) {
		2781	+ parentElem = element.Parent()->ToElement();
		2782	+ }
		2783	+ const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
		2784	+ OpenElement( element.Name(), compactMode );
		2785	+ while ( attribute ) {
		2786	+ PushAttribute( attribute->Name(), attribute->Value() );
		2787	+ attribute = attribute->Next();
		2788	+ }
		2789	+ return true;
		2790	+}
		2791	+
		2792	+
		2793	+bool XMLPrinter::VisitExit( const XMLElement& element )
		2794	+{
		2795	+ CloseElement( CompactMode(element) );
		2796	+ return true;
		2797	+}
		2798	+
		2799	+
		2800	+bool XMLPrinter::Visit( const XMLText& text )
		2801	+{
		2802	+ PushText( text.Value(), text.CData() );
		2803	+ return true;
		2804	+}
		2805	+
		2806	+
		2807	+bool XMLPrinter::Visit( const XMLComment& comment )
		2808	+{
		2809	+ PushComment( comment.Value() );
		2810	+ return true;
		2811	+}
		2812	+
		2813	+bool XMLPrinter::Visit( const XMLDeclaration& declaration )
		2814	+{
		2815	+ PushDeclaration( declaration.Value() );
		2816	+ return true;
		2817	+}
		2818	+
		2819	+
		2820	+bool XMLPrinter::Visit( const XMLUnknown& unknown )
		2821	+{
		2822	+ PushUnknown( unknown.Value() );
		2823	+ return true;
		2824	+}
		2825	+
		2826	+} // namespace tinyxml2

sip/tinyxml2/tinyxml2.h 0 → 100644

View file @c887a0f

		1	+++ a/sip/tinyxml2/tinyxml2.h
		1	+/*
		2	+Original code by Lee Thomason (www.grinninglizard.com)
		3	+
		4	+This software is provided 'as-is', without any express or implied
		5	+warranty. In no event will the authors be held liable for any
		6	+damages arising from the use of this software.
		7	+
		8	+Permission is granted to anyone to use this software for any
		9	+purpose, including commercial applications, and to alter it and
		10	+redistribute it freely, subject to the following restrictions:
		11	+
		12	+1. The origin of this software must not be misrepresented; you must
		13	+not claim that you wrote the original software. If you use this
		14	+software in a product, an acknowledgment in the product documentation
		15	+would be appreciated but is not required.
		16	+
		17	+2. Altered source versions must be plainly marked as such, and
		18	+must not be misrepresented as being the original software.
		19	+
		20	+3. This notice may not be removed or altered from any source
		21	+distribution.
		22	+*/
		23	+
		24	+#ifndef TINYXML2_INCLUDED
		25	+#define TINYXML2_INCLUDED
		26	+
		27	+#if defined(ANDROID_NDK) \|\| defined(__BORLANDC__) \|\| defined(__QNXNTO__)
		28	+# include <ctype.h>
		29	+# include <limits.h>
		30	+# include <stdio.h>
		31	+# include <stdlib.h>
		32	+# include <string.h>
		33	+# if defined(__PS3__)
		34	+# include <stddef.h>
		35	+# endif
		36	+#else
		37	+# include <cctype>
		38	+# include <climits>
		39	+# include <cstdio>
		40	+# include <cstdlib>
		41	+# include <cstring>
		42	+#endif
		43	+#include <stdint.h>
		44	+
		45	+/*
		46	+ TODO: intern strings instead of allocation.
		47	+*/
		48	+/*
		49	+ gcc:
		50	+ g++ -Wall -DTINYXML2_DEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
		51	+
		52	+ Formatting, Artistic Style:
		53	+ AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
		54	+*/
		55	+
		56	+#if defined( _DEBUG ) \|\| defined (__DEBUG__)
		57	+# ifndef TINYXML2_DEBUG
		58	+# define TINYXML2_DEBUG
		59	+# endif
		60	+#endif
		61	+
		62	+#ifdef _MSC_VER
		63	+# pragma warning(push)
		64	+# pragma warning(disable: 4251)
		65	+#endif
		66	+
		67	+#ifdef _WIN32
		68	+# ifdef TINYXML2_EXPORT
		69	+# define TINYXML2_LIB __declspec(dllexport)
		70	+# elif defined(TINYXML2_IMPORT)
		71	+# define TINYXML2_LIB __declspec(dllimport)
		72	+# else
		73	+# define TINYXML2_LIB
		74	+# endif
		75	+#elif __GNUC__ >= 4
		76	+# define TINYXML2_LIB __attribute__((visibility("default")))
		77	+#else
		78	+# define TINYXML2_LIB
		79	+#endif
		80	+
		81	+
		82	+#if defined(TINYXML2_DEBUG)
		83	+# if defined(_MSC_VER)
		84	+# // "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
		85	+# define TIXMLASSERT( x ) if ( !((void)0,(x))) { __debugbreak(); }
		86	+# elif defined (ANDROID_NDK)
		87	+# include <android/log.h>
		88	+# define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
		89	+# else
		90	+# include <assert.h>
		91	+# define TIXMLASSERT assert
		92	+# endif
		93	+#else
		94	+# define TIXMLASSERT( x ) {}
		95	+#endif
		96	+
		97	+
		98	+/* Versioning, past 1.0.14:
		99	+ http://semver.org/
		100	+*/
		101	+static const int TIXML2_MAJOR_VERSION = 6;
		102	+static const int TIXML2_MINOR_VERSION = 2;
		103	+static const int TIXML2_PATCH_VERSION = 0;
		104	+
		105	+#define TINYXML2_MAJOR_VERSION 6
		106	+#define TINYXML2_MINOR_VERSION 2
		107	+#define TINYXML2_PATCH_VERSION 0
		108	+
		109	+// A fixed element depth limit is problematic. There needs to be a
		110	+// limit to avoid a stack overflow. However, that limit varies per
		111	+// system, and the capacity of the stack. On the other hand, it's a trivial
		112	+// attack that can result from ill, malicious, or even correctly formed XML,
		113	+// so there needs to be a limit in place.
		114	+static const int TINYXML2_MAX_ELEMENT_DEPTH = 100;
		115	+
		116	+namespace tinyxml2
		117	+{
		118	+class XMLDocument;
		119	+class XMLElement;
		120	+class XMLAttribute;
		121	+class XMLComment;
		122	+class XMLText;
		123	+class XMLDeclaration;
		124	+class XMLUnknown;
		125	+class XMLPrinter;
		126	+
		127	+/*
		128	+ A class that wraps strings. Normally stores the start and end
		129	+ pointers into the XML file itself, and will apply normalization
		130	+ and entity translation if actually read. Can also store (and memory
		131	+ manage) a traditional char[]
		132	+*/
		133	+class StrPair
		134	+{
		135	+public:
		136	+ enum {
		137	+ NEEDS_ENTITY_PROCESSING = 0x01,
		138	+ NEEDS_NEWLINE_NORMALIZATION = 0x02,
		139	+ NEEDS_WHITESPACE_COLLAPSING = 0x04,
		140	+
		141	+ TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING \| NEEDS_NEWLINE_NORMALIZATION,
		142	+ TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
		143	+ ATTRIBUTE_NAME = 0,
		144	+ ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING \| NEEDS_NEWLINE_NORMALIZATION,
		145	+ ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
		146	+ COMMENT = NEEDS_NEWLINE_NORMALIZATION
		147	+ };
		148	+
		149	+ StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
		150	+ ~StrPair();
		151	+
		152	+ void Set( char* start, char* end, int flags ) {
		153	+ TIXMLASSERT( start );
		154	+ TIXMLASSERT( end );
		155	+ Reset();
		156	+ _start = start;
		157	+ _end = end;
		158	+ _flags = flags \| NEEDS_FLUSH;
		159	+ }
		160	+
		161	+ const char* GetStr();
		162	+
		163	+ bool Empty() const {
		164	+ return _start == _end;
		165	+ }
		166	+
		167	+ void SetInternedStr( const char* str ) {
		168	+ Reset();
		169	+ _start = const_cast<char*>(str);
		170	+ }
		171	+
		172	+ void SetStr( const char* str, int flags=0 );
		173	+
		174	+ char* ParseText( char* in, const char* endTag, int strFlags, int* curLineNumPtr );
		175	+ char* ParseName( char* in );
		176	+
		177	+ void TransferTo( StrPair* other );
		178	+ void Reset();
		179	+
		180	+private:
		181	+ void CollapseWhitespace();
		182	+
		183	+ enum {
		184	+ NEEDS_FLUSH = 0x100,
		185	+ NEEDS_DELETE = 0x200
		186	+ };
		187	+
		188	+ int _flags;
		189	+ char* _start;
		190	+ char* _end;
		191	+
		192	+ StrPair( const StrPair& other ); // not supported
		193	+ void operator=( StrPair& other ); // not supported, use TransferTo()
		194	+};
		195	+
		196	+
		197	+/*
		198	+ A dynamic array of Plain Old Data. Doesn't support constructors, etc.
		199	+ Has a small initial memory pool, so that low or no usage will not
		200	+ cause a call to new/delete
		201	+*/
		202	+template <class T, int INITIAL_SIZE>
		203	+class DynArray
		204	+{
		205	+public:
		206	+ DynArray() :
		207	+ _mem( _pool ),
		208	+ _allocated( INITIAL_SIZE ),
		209	+ _size( 0 )
		210	+ {
		211	+ }
		212	+
		213	+ ~DynArray() {
		214	+ if ( _mem != _pool ) {
		215	+ delete [] _mem;
		216	+ }
		217	+ }
		218	+
		219	+ void Clear() {
		220	+ _size = 0;
		221	+ }
		222	+
		223	+ void Push( T t ) {
		224	+ TIXMLASSERT( _size < INT_MAX );
		225	+ EnsureCapacity( _size+1 );
		226	+ _mem[_size] = t;
		227	+ ++_size;
		228	+ }
		229	+
		230	+ T* PushArr( int count ) {
		231	+ TIXMLASSERT( count >= 0 );
		232	+ TIXMLASSERT( _size <= INT_MAX - count );
		233	+ EnsureCapacity( _size+count );
		234	+ T* ret = &_mem[_size];
		235	+ _size += count;
		236	+ return ret;
		237	+ }
		238	+
		239	+ T Pop() {
		240	+ TIXMLASSERT( _size > 0 );
		241	+ --_size;
		242	+ return _mem[_size];
		243	+ }
		244	+
		245	+ void PopArr( int count ) {
		246	+ TIXMLASSERT( _size >= count );
		247	+ _size -= count;
		248	+ }
		249	+
		250	+ bool Empty() const {
		251	+ return _size == 0;
		252	+ }
		253	+
		254	+ T& operator[](int i) {
		255	+ TIXMLASSERT( i>= 0 && i < _size );
		256	+ return _mem[i];
		257	+ }
		258	+
		259	+ const T& operator[](int i) const {
		260	+ TIXMLASSERT( i>= 0 && i < _size );
		261	+ return _mem[i];
		262	+ }
		263	+
		264	+ const T& PeekTop() const {
		265	+ TIXMLASSERT( _size > 0 );
		266	+ return _mem[ _size - 1];
		267	+ }
		268	+
		269	+ int Size() const {
		270	+ TIXMLASSERT( _size >= 0 );
		271	+ return _size;
		272	+ }
		273	+
		274	+ int Capacity() const {
		275	+ TIXMLASSERT( _allocated >= INITIAL_SIZE );
		276	+ return _allocated;
		277	+ }
		278	+
		279	+ void SwapRemove(int i) {
		280	+ TIXMLASSERT(i >= 0 && i < _size);
		281	+ TIXMLASSERT(_size > 0);
		282	+ _mem[i] = _mem[_size - 1];
		283	+ --_size;
		284	+ }
		285	+
		286	+ const T* Mem() const {
		287	+ TIXMLASSERT( _mem );
		288	+ return _mem;
		289	+ }
		290	+
		291	+ T* Mem() {
		292	+ TIXMLASSERT( _mem );
		293	+ return _mem;
		294	+ }
		295	+
		296	+private:
		297	+ DynArray( const DynArray& ); // not supported
		298	+ void operator=( const DynArray& ); // not supported
		299	+
		300	+ void EnsureCapacity( int cap ) {
		301	+ TIXMLASSERT( cap > 0 );
		302	+ if ( cap > _allocated ) {
		303	+ TIXMLASSERT( cap <= INT_MAX / 2 );
		304	+ int newAllocated = cap * 2;
		305	+ T* newMem = new T[newAllocated];
		306	+ TIXMLASSERT( newAllocated >= _size );
		307	+ memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
		308	+ if ( _mem != _pool ) {
		309	+ delete [] _mem;
		310	+ }
		311	+ _mem = newMem;
		312	+ _allocated = newAllocated;
		313	+ }
		314	+ }
		315	+
		316	+ T* _mem;
		317	+ T _pool[INITIAL_SIZE];
		318	+ int _allocated; // objects allocated
		319	+ int _size; // number objects in use
		320	+};
		321	+
		322	+
		323	+/*
		324	+ Parent virtual class of a pool for fast allocation
		325	+ and deallocation of objects.
		326	+*/
		327	+class MemPool
		328	+{
		329	+public:
		330	+ MemPool() {}
		331	+ virtual ~MemPool() {}
		332	+
		333	+ virtual int ItemSize() const = 0;
		334	+ virtual void* Alloc() = 0;
		335	+ virtual void Free( void* ) = 0;
		336	+ virtual void SetTracked() = 0;
		337	+ virtual void Clear() = 0;
		338	+};
		339	+
		340	+
		341	+/*
		342	+ Template child class to create pools of the correct type.
		343	+*/
		344	+template< int ITEM_SIZE >
		345	+class MemPoolT : public MemPool
		346	+{
		347	+public:
		348	+ MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
		349	+ ~MemPoolT() {
		350	+ Clear();
		351	+ }
		352	+
		353	+ void Clear() {
		354	+ // Delete the blocks.
		355	+ while( !_blockPtrs.Empty()) {
		356	+ Block* lastBlock = _blockPtrs.Pop();
		357	+ delete lastBlock;
		358	+ }
		359	+ _root = 0;
		360	+ _currentAllocs = 0;
		361	+ _nAllocs = 0;
		362	+ _maxAllocs = 0;
		363	+ _nUntracked = 0;
		364	+ }
		365	+
		366	+ virtual int ItemSize() const {
		367	+ return ITEM_SIZE;
		368	+ }
		369	+ int CurrentAllocs() const {
		370	+ return _currentAllocs;
		371	+ }
		372	+
		373	+ virtual void* Alloc() {
		374	+ if ( !_root ) {
		375	+ // Need a new block.
		376	+ Block* block = new Block();
		377	+ _blockPtrs.Push( block );
		378	+
		379	+ Item* blockItems = block->items;
		380	+ for( int i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
		381	+ blockItems[i].next = &(blockItems[i + 1]);
		382	+ }
		383	+ blockItems[ITEMS_PER_BLOCK - 1].next = 0;
		384	+ _root = blockItems;
		385	+ }
		386	+ Item* const result = _root;
		387	+ TIXMLASSERT( result != 0 );
		388	+ _root = _root->next;
		389	+
		390	+ ++_currentAllocs;
		391	+ if ( _currentAllocs > _maxAllocs ) {
		392	+ _maxAllocs = _currentAllocs;
		393	+ }
		394	+ ++_nAllocs;
		395	+ ++_nUntracked;
		396	+ return result;
		397	+ }
		398	+
		399	+ virtual void Free( void* mem ) {
		400	+ if ( !mem ) {
		401	+ return;
		402	+ }
		403	+ --_currentAllocs;
		404	+ Item* item = static_cast<Item*>( mem );
		405	+#ifdef TINYXML2_DEBUG
		406	+ memset( item, 0xfe, sizeof( *item ) );
		407	+#endif
		408	+ item->next = _root;
		409	+ _root = item;
		410	+ }
		411	+ void Trace( const char* name ) {
		412	+ printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
		413	+ name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
		414	+ ITEM_SIZE, _nAllocs, _blockPtrs.Size() );
		415	+ }
		416	+
		417	+ void SetTracked() {
		418	+ --_nUntracked;
		419	+ }
		420	+
		421	+ int Untracked() const {
		422	+ return _nUntracked;
		423	+ }
		424	+
		425	+ // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
		426	+ // The test file is large, 170k.
		427	+ // Release: VS2010 gcc(no opt)
		428	+ // 1k: 4000
		429	+ // 2k: 4000
		430	+ // 4k: 3900 21000
		431	+ // 16k: 5200
		432	+ // 32k: 4300
		433	+ // 64k: 4000 21000
		434	+ // Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
		435	+ // in private part if ITEMS_PER_BLOCK is private
		436	+ enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };
		437	+
		438	+private:
		439	+ MemPoolT( const MemPoolT& ); // not supported
		440	+ void operator=( const MemPoolT& ); // not supported
		441	+
		442	+ union Item {
		443	+ Item* next;
		444	+ char itemData[ITEM_SIZE];
		445	+ };
		446	+ struct Block {
		447	+ Item items[ITEMS_PER_BLOCK];
		448	+ };
		449	+ DynArray< Block*, 10 > _blockPtrs;
		450	+ Item* _root;
		451	+
		452	+ int _currentAllocs;
		453	+ int _nAllocs;
		454	+ int _maxAllocs;
		455	+ int _nUntracked;
		456	+};
		457	+
		458	+
		459	+
		460	+/**
		461	+ Implements the interface to the "Visitor pattern" (see the Accept() method.)
		462	+ If you call the Accept() method, it requires being passed a XMLVisitor
		463	+ class to handle callbacks. For nodes that contain other nodes (Document, Element)
		464	+ you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
		465	+ are simply called with Visit().
		466	+
		467	+ If you return 'true' from a Visit method, recursive parsing will continue. If you return
		468	+ false, <b>no children of this node or its siblings</b> will be visited.
		469	+
		470	+ All flavors of Visit methods have a default implementation that returns 'true' (continue
		471	+ visiting). You need to only override methods that are interesting to you.
		472	+
		473	+ Generally Accept() is called on the XMLDocument, although all nodes support visiting.
		474	+
		475	+ You should never change the document from a callback.
		476	+
		477	+ @sa XMLNode::Accept()
		478	+*/
		479	+class TINYXML2_LIB XMLVisitor
		480	+{
		481	+public:
		482	+ virtual ~XMLVisitor() {}
		483	+
		484	+ /// Visit a document.
		485	+ virtual bool VisitEnter( const XMLDocument& /doc/ ) {
		486	+ return true;
		487	+ }
		488	+ /// Visit a document.
		489	+ virtual bool VisitExit( const XMLDocument& /doc/ ) {
		490	+ return true;
		491	+ }
		492	+
		493	+ /// Visit an element.
		494	+ virtual bool VisitEnter( const XMLElement& /element/, const XMLAttribute* /firstAttribute/ ) {
		495	+ return true;
		496	+ }
		497	+ /// Visit an element.
		498	+ virtual bool VisitExit( const XMLElement& /element/ ) {
		499	+ return true;
		500	+ }
		501	+
		502	+ /// Visit a declaration.
		503	+ virtual bool Visit( const XMLDeclaration& /declaration/ ) {
		504	+ return true;
		505	+ }
		506	+ /// Visit a text node.
		507	+ virtual bool Visit( const XMLText& /text/ ) {
		508	+ return true;
		509	+ }
		510	+ /// Visit a comment node.
		511	+ virtual bool Visit( const XMLComment& /comment/ ) {
		512	+ return true;
		513	+ }
		514	+ /// Visit an unknown node.
		515	+ virtual bool Visit( const XMLUnknown& /unknown/ ) {
		516	+ return true;
		517	+ }
		518	+};
		519	+
		520	+// WARNING: must match XMLDocument::_errorNames[]
		521	+enum XMLError {
		522	+ XML_SUCCESS = 0,
		523	+ XML_NO_ATTRIBUTE,
		524	+ XML_WRONG_ATTRIBUTE_TYPE,
		525	+ XML_ERROR_FILE_NOT_FOUND,
		526	+ XML_ERROR_FILE_COULD_NOT_BE_OPENED,
		527	+ XML_ERROR_FILE_READ_ERROR,
		528	+ UNUSED_XML_ERROR_ELEMENT_MISMATCH, // remove at next major version
		529	+ XML_ERROR_PARSING_ELEMENT,
		530	+ XML_ERROR_PARSING_ATTRIBUTE,
		531	+ UNUSED_XML_ERROR_IDENTIFYING_TAG, // remove at next major version
		532	+ XML_ERROR_PARSING_TEXT,
		533	+ XML_ERROR_PARSING_CDATA,
		534	+ XML_ERROR_PARSING_COMMENT,
		535	+ XML_ERROR_PARSING_DECLARATION,
		536	+ XML_ERROR_PARSING_UNKNOWN,
		537	+ XML_ERROR_EMPTY_DOCUMENT,
		538	+ XML_ERROR_MISMATCHED_ELEMENT,
		539	+ XML_ERROR_PARSING,
		540	+ XML_CAN_NOT_CONVERT_TEXT,
		541	+ XML_NO_TEXT_NODE,
		542	+ XML_ELEMENT_DEPTH_EXCEEDED,
		543	+
		544	+ XML_ERROR_COUNT
		545	+};
		546	+
		547	+
		548	+/*
		549	+ Utility functionality.
		550	+*/
		551	+class TINYXML2_LIB XMLUtil
		552	+{
		553	+public:
		554	+ static const char* SkipWhiteSpace( const char* p, int* curLineNumPtr ) {
		555	+ TIXMLASSERT( p );
		556	+
		557	+ while( IsWhiteSpace(*p) ) {
		558	+ if (curLineNumPtr && *p == '\n') {
		559	+ ++(*curLineNumPtr);
		560	+ }
		561	+ ++p;
		562	+ }
		563	+ TIXMLASSERT( p );
		564	+ return p;
		565	+ }
		566	+ static char* SkipWhiteSpace( char* p, int* curLineNumPtr ) {
		567	+ return const_cast<char>( SkipWhiteSpace( const_cast<const char>(p), curLineNumPtr ) );
		568	+ }
		569	+
		570	+ // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
		571	+ // correct, but simple, and usually works.
		572	+ static bool IsWhiteSpace( char p ) {
		573	+ return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
		574	+ }
		575	+
		576	+ inline static bool IsNameStartChar( unsigned char ch ) {
		577	+ if ( ch >= 128 ) {
		578	+ // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
		579	+ return true;
		580	+ }
		581	+ if ( isalpha( ch ) ) {
		582	+ return true;
		583	+ }
		584	+ return ch == ':' \|\| ch == '_';
		585	+ }
		586	+
		587	+ inline static bool IsNameChar( unsigned char ch ) {
		588	+ return IsNameStartChar( ch )
		589	+ \|\| isdigit( ch )
		590	+ \|\| ch == '.'
		591	+ \|\| ch == '-';
		592	+ }
		593	+
		594	+ inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
		595	+ if ( p == q ) {
		596	+ return true;
		597	+ }
		598	+ TIXMLASSERT( p );
		599	+ TIXMLASSERT( q );
		600	+ TIXMLASSERT( nChar >= 0 );
		601	+ return strncmp( p, q, nChar ) == 0;
		602	+ }
		603	+
		604	+ inline static bool IsUTF8Continuation( char p ) {
		605	+ return ( p & 0x80 ) != 0;
		606	+ }
		607	+
		608	+ static const char* ReadBOM( const char* p, bool* hasBOM );
		609	+ // p is the starting location,
		610	+ // the UTF-8 value of the entity will be placed in value, and length filled in.
		611	+ static const char* GetCharacterRef( const char* p, char* value, int* length );
		612	+ static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
		613	+
		614	+ // converts primitive types to strings
		615	+ static void ToStr( int v, char* buffer, int bufferSize );
		616	+ static void ToStr( unsigned v, char* buffer, int bufferSize );
		617	+ static void ToStr( bool v, char* buffer, int bufferSize );
		618	+ static void ToStr( float v, char* buffer, int bufferSize );
		619	+ static void ToStr( double v, char* buffer, int bufferSize );
		620	+ static void ToStr(int64_t v, char* buffer, int bufferSize);
		621	+
		622	+ // converts strings to primitive types
		623	+ static bool ToInt( const char* str, int* value );
		624	+ static bool ToUnsigned( const char* str, unsigned* value );
		625	+ static bool ToBool( const char* str, bool* value );
		626	+ static bool ToFloat( const char* str, float* value );
		627	+ static bool ToDouble( const char* str, double* value );
		628	+ static bool ToInt64(const char* str, int64_t* value);
		629	+
		630	+ // Changes what is serialized for a boolean value.
		631	+ // Default to "true" and "false". Shouldn't be changed
		632	+ // unless you have a special testing or compatibility need.
		633	+ // Be careful: static, global, & not thread safe.
		634	+ // Be sure to set static const memory as parameters.
		635	+ static void SetBoolSerialization(const char* writeTrue, const char* writeFalse);
		636	+
		637	+private:
		638	+ static const char* writeBoolTrue;
		639	+ static const char* writeBoolFalse;
		640	+};
		641	+
		642	+
		643	+/** XMLNode is a base class for every object that is in the
		644	+ XML Document Object Model (DOM), except XMLAttributes.
		645	+ Nodes have siblings, a parent, and children which can
		646	+ be navigated. A node is always in a XMLDocument.
		647	+ The type of a XMLNode can be queried, and it can
		648	+ be cast to its more defined type.
		649	+
		650	+ A XMLDocument allocates memory for all its Nodes.
		651	+ When the XMLDocument gets deleted, all its Nodes
		652	+ will also be deleted.
		653	+
		654	+ @verbatim
		655	+ A Document can contain: Element (container or leaf)
		656	+ Comment (leaf)
		657	+ Unknown (leaf)
		658	+ Declaration( leaf )
		659	+
		660	+ An Element can contain: Element (container or leaf)
		661	+ Text (leaf)
		662	+ Attributes (not on tree)
		663	+ Comment (leaf)
		664	+ Unknown (leaf)
		665	+
		666	+ @endverbatim
		667	+*/
		668	+class TINYXML2_LIB XMLNode
		669	+{
		670	+ friend class XMLDocument;
		671	+ friend class XMLElement;
		672	+public:
		673	+
		674	+ /// Get the XMLDocument that owns this XMLNode.
		675	+ const XMLDocument* GetDocument() const {
		676	+ TIXMLASSERT( _document );
		677	+ return _document;
		678	+ }
		679	+ /// Get the XMLDocument that owns this XMLNode.
		680	+ XMLDocument* GetDocument() {
		681	+ TIXMLASSERT( _document );
		682	+ return _document;
		683	+ }
		684	+
		685	+ /// Safely cast to an Element, or null.
		686	+ virtual XMLElement* ToElement() {
		687	+ return 0;
		688	+ }
		689	+ /// Safely cast to Text, or null.
		690	+ virtual XMLText* ToText() {
		691	+ return 0;
		692	+ }
		693	+ /// Safely cast to a Comment, or null.
		694	+ virtual XMLComment* ToComment() {
		695	+ return 0;
		696	+ }
		697	+ /// Safely cast to a Document, or null.
		698	+ virtual XMLDocument* ToDocument() {
		699	+ return 0;
		700	+ }
		701	+ /// Safely cast to a Declaration, or null.
		702	+ virtual XMLDeclaration* ToDeclaration() {
		703	+ return 0;
		704	+ }
		705	+ /// Safely cast to an Unknown, or null.
		706	+ virtual XMLUnknown* ToUnknown() {
		707	+ return 0;
		708	+ }
		709	+
		710	+ virtual const XMLElement* ToElement() const {
		711	+ return 0;
		712	+ }
		713	+ virtual const XMLText* ToText() const {
		714	+ return 0;
		715	+ }
		716	+ virtual const XMLComment* ToComment() const {
		717	+ return 0;
		718	+ }
		719	+ virtual const XMLDocument* ToDocument() const {
		720	+ return 0;
		721	+ }
		722	+ virtual const XMLDeclaration* ToDeclaration() const {
		723	+ return 0;
		724	+ }
		725	+ virtual const XMLUnknown* ToUnknown() const {
		726	+ return 0;
		727	+ }
		728	+
		729	+ /** The meaning of 'value' changes for the specific type.
		730	+ @verbatim
		731	+ Document: empty (NULL is returned, not an empty string)
		732	+ Element: name of the element
		733	+ Comment: the comment text
		734	+ Unknown: the tag contents
		735	+ Text: the text string
		736	+ @endverbatim
		737	+ */
		738	+ const char* Value() const;
		739	+
		740	+ /** Set the Value of an XML node.
		741	+ @sa Value()
		742	+ */
		743	+ void SetValue( const char* val, bool staticMem=false );
		744	+
		745	+ /// Gets the line number the node is in, if the document was parsed from a file.
		746	+ int GetLineNum() const { return _parseLineNum; }
		747	+
		748	+ /// Get the parent of this node on the DOM.
		749	+ const XMLNode* Parent() const {
		750	+ return _parent;
		751	+ }
		752	+
		753	+ XMLNode* Parent() {
		754	+ return _parent;
		755	+ }
		756	+
		757	+ /// Returns true if this node has no children.
		758	+ bool NoChildren() const {
		759	+ return !_firstChild;
		760	+ }
		761	+
		762	+ /// Get the first child node, or null if none exists.
		763	+ const XMLNode* FirstChild() const {
		764	+ return _firstChild;
		765	+ }
		766	+
		767	+ XMLNode* FirstChild() {
		768	+ return _firstChild;
		769	+ }
		770	+
		771	+ /** Get the first child element, or optionally the first child
		772	+ element with the specified name.
		773	+ */
		774	+ const XMLElement* FirstChildElement( const char* name = 0 ) const;
		775	+
		776	+ XMLElement* FirstChildElement( const char* name = 0 ) {
		777	+ return const_cast<XMLElement>(const_cast<const XMLNode>(this)->FirstChildElement( name ));
		778	+ }
		779	+
		780	+ /// Get the last child node, or null if none exists.
		781	+ const XMLNode* LastChild() const {
		782	+ return _lastChild;
		783	+ }
		784	+
		785	+ XMLNode* LastChild() {
		786	+ return _lastChild;
		787	+ }
		788	+
		789	+ /** Get the last child element or optionally the last child
		790	+ element with the specified name.
		791	+ */
		792	+ const XMLElement* LastChildElement( const char* name = 0 ) const;
		793	+
		794	+ XMLElement* LastChildElement( const char* name = 0 ) {
		795	+ return const_cast<XMLElement>(const_cast<const XMLNode>(this)->LastChildElement(name) );
		796	+ }
		797	+
		798	+ /// Get the previous (left) sibling node of this node.
		799	+ const XMLNode* PreviousSibling() const {
		800	+ return _prev;
		801	+ }
		802	+
		803	+ XMLNode* PreviousSibling() {
		804	+ return _prev;
		805	+ }
		806	+
		807	+ /// Get the previous (left) sibling element of this node, with an optionally supplied name.
		808	+ const XMLElement* PreviousSiblingElement( const char* name = 0 ) const ;
		809	+
		810	+ XMLElement* PreviousSiblingElement( const char* name = 0 ) {
		811	+ return const_cast<XMLElement>(const_cast<const XMLNode>(this)->PreviousSiblingElement( name ) );
		812	+ }
		813	+
		814	+ /// Get the next (right) sibling node of this node.
		815	+ const XMLNode* NextSibling() const {
		816	+ return _next;
		817	+ }
		818	+
		819	+ XMLNode* NextSibling() {
		820	+ return _next;
		821	+ }
		822	+
		823	+ /// Get the next (right) sibling element of this node, with an optionally supplied name.
		824	+ const XMLElement* NextSiblingElement( const char* name = 0 ) const;
		825	+
		826	+ XMLElement* NextSiblingElement( const char* name = 0 ) {
		827	+ return const_cast<XMLElement>(const_cast<const XMLNode>(this)->NextSiblingElement( name ) );
		828	+ }
		829	+
		830	+ /**
		831	+ Add a child node as the last (right) child.
		832	+ If the child node is already part of the document,
		833	+ it is moved from its old location to the new location.
		834	+ Returns the addThis argument or 0 if the node does not
		835	+ belong to the same document.
		836	+ */
		837	+ XMLNode* InsertEndChild( XMLNode* addThis );
		838	+
		839	+ XMLNode* LinkEndChild( XMLNode* addThis ) {
		840	+ return InsertEndChild( addThis );
		841	+ }
		842	+ /**
		843	+ Add a child node as the first (left) child.
		844	+ If the child node is already part of the document,
		845	+ it is moved from its old location to the new location.
		846	+ Returns the addThis argument or 0 if the node does not
		847	+ belong to the same document.
		848	+ */
		849	+ XMLNode* InsertFirstChild( XMLNode* addThis );
		850	+ /**
		851	+ Add a node after the specified child node.
		852	+ If the child node is already part of the document,
		853	+ it is moved from its old location to the new location.
		854	+ Returns the addThis argument or 0 if the afterThis node
		855	+ is not a child of this node, or if the node does not
		856	+ belong to the same document.
		857	+ */
		858	+ XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
		859	+
		860	+ /**
		861	+ Delete all the children of this node.
		862	+ */
		863	+ void DeleteChildren();
		864	+
		865	+ /**
		866	+ Delete a child of this node.
		867	+ */
		868	+ void DeleteChild( XMLNode* node );
		869	+
		870	+ /**
		871	+ Make a copy of this node, but not its children.
		872	+ You may pass in a Document pointer that will be
		873	+ the owner of the new Node. If the 'document' is
		874	+ null, then the node returned will be allocated
		875	+ from the current Document. (this->GetDocument())
		876	+
		877	+ Note: if called on a XMLDocument, this will return null.
		878	+ */
		879	+ virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
		880	+
		881	+ /**
		882	+ Make a copy of this node and all its children.
		883	+
		884	+ If the 'target' is null, then the nodes will
		885	+ be allocated in the current document. If 'target'
		886	+ is specified, the memory will be allocated is the
		887	+ specified XMLDocument.
		888	+
		889	+ NOTE: This is probably not the correct tool to
		890	+ copy a document, since XMLDocuments can have multiple
		891	+ top level XMLNodes. You probably want to use
		892	+ XMLDocument::DeepCopy()
		893	+ */
		894	+ XMLNode* DeepClone( XMLDocument* target ) const;
		895	+
		896	+ /**
		897	+ Test if 2 nodes are the same, but don't test children.
		898	+ The 2 nodes do not need to be in the same Document.
		899	+
		900	+ Note: if called on a XMLDocument, this will return false.
		901	+ */
		902	+ virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
		903	+
		904	+ /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
		905	+ XML tree will be conditionally visited and the host will be called back
		906	+ via the XMLVisitor interface.
		907	+
		908	+ This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
		909	+ the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
		910	+ interface versus any other.)
		911	+
		912	+ The interface has been based on ideas from:
		913	+
		914	+ - http://www.saxproject.org/
		915	+ - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
		916	+
		917	+ Which are both good references for "visiting".
		918	+
		919	+ An example of using Accept():
		920	+ @verbatim
		921	+ XMLPrinter printer;
		922	+ tinyxmlDoc.Accept( &printer );
		923	+ const char* xmlcstr = printer.CStr();
		924	+ @endverbatim
		925	+ */
		926	+ virtual bool Accept( XMLVisitor* visitor ) const = 0;
		927	+
		928	+ /**
		929	+ Set user data into the XMLNode. TinyXML-2 in
		930	+ no way processes or interprets user data.
		931	+ It is initially 0.
		932	+ */
		933	+ void SetUserData(void* userData) { _userData = userData; }
		934	+
		935	+ /**
		936	+ Get user data set into the XMLNode. TinyXML-2 in
		937	+ no way processes or interprets user data.
		938	+ It is initially 0.
		939	+ */
		940	+ void* GetUserData() const { return _userData; }
		941	+
		942	+protected:
		943	+ XMLNode( XMLDocument* );
		944	+ virtual ~XMLNode();
		945	+
		946	+ virtual char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
		947	+
		948	+ XMLDocument* _document;
		949	+ XMLNode* _parent;
		950	+ mutable StrPair _value;
		951	+ int _parseLineNum;
		952	+
		953	+ XMLNode* _firstChild;
		954	+ XMLNode* _lastChild;
		955	+
		956	+ XMLNode* _prev;
		957	+ XMLNode* _next;
		958	+
		959	+ void* _userData;
		960	+
		961	+private:
		962	+ MemPool* _memPool;
		963	+ void Unlink( XMLNode* child );
		964	+ static void DeleteNode( XMLNode* node );
		965	+ void InsertChildPreamble( XMLNode* insertThis ) const;
		966	+ const XMLElement* ToElementWithName( const char* name ) const;
		967	+
		968	+ XMLNode( const XMLNode& ); // not supported
		969	+ XMLNode& operator=( const XMLNode& ); // not supported
		970	+};
		971	+
		972	+
		973	+/** XML text.
		974	+
		975	+ Note that a text node can have child element nodes, for example:
		976	+ @verbatim
		977	+ <root>This is <b>bold</b></root>
		978	+ @endverbatim
		979	+
		980	+ A text node can have 2 ways to output the next. "normal" output
		981	+ and CDATA. It will default to the mode it was parsed from the XML file and
		982	+ you generally want to leave it alone, but you can change the output mode with
		983	+ SetCData() and query it with CData().
		984	+*/
		985	+class TINYXML2_LIB XMLText : public XMLNode
		986	+{
		987	+ friend class XMLDocument;
		988	+public:
		989	+ virtual bool Accept( XMLVisitor* visitor ) const;
		990	+
		991	+ virtual XMLText* ToText() {
		992	+ return this;
		993	+ }
		994	+ virtual const XMLText* ToText() const {
		995	+ return this;
		996	+ }
		997	+
		998	+ /// Declare whether this should be CDATA or standard text.
		999	+ void SetCData( bool isCData ) {
		1000	+ _isCData = isCData;
		1001	+ }
		1002	+ /// Returns true if this is a CDATA text element.
		1003	+ bool CData() const {
		1004	+ return _isCData;
		1005	+ }
		1006	+
		1007	+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
		1008	+ virtual bool ShallowEqual( const XMLNode* compare ) const;
		1009	+
		1010	+protected:
		1011	+ XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
		1012	+ virtual ~XMLText() {}
		1013	+
		1014	+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
		1015	+
		1016	+private:
		1017	+ bool _isCData;
		1018	+
		1019	+ XMLText( const XMLText& ); // not supported
		1020	+ XMLText& operator=( const XMLText& ); // not supported
		1021	+};
		1022	+
		1023	+
		1024	+/** An XML Comment. */
		1025	+class TINYXML2_LIB XMLComment : public XMLNode
		1026	+{
		1027	+ friend class XMLDocument;
		1028	+public:
		1029	+ virtual XMLComment* ToComment() {
		1030	+ return this;
		1031	+ }
		1032	+ virtual const XMLComment* ToComment() const {
		1033	+ return this;
		1034	+ }
		1035	+
		1036	+ virtual bool Accept( XMLVisitor* visitor ) const;
		1037	+
		1038	+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
		1039	+ virtual bool ShallowEqual( const XMLNode* compare ) const;
		1040	+
		1041	+protected:
		1042	+ XMLComment( XMLDocument* doc );
		1043	+ virtual ~XMLComment();
		1044	+
		1045	+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
		1046	+
		1047	+private:
		1048	+ XMLComment( const XMLComment& ); // not supported
		1049	+ XMLComment& operator=( const XMLComment& ); // not supported
		1050	+};
		1051	+
		1052	+
		1053	+/** In correct XML the declaration is the first entry in the file.
		1054	+ @verbatim
		1055	+ <?xml version="1.0" standalone="yes"?>
		1056	+ @endverbatim
		1057	+
		1058	+ TinyXML-2 will happily read or write files without a declaration,
		1059	+ however.
		1060	+
		1061	+ The text of the declaration isn't interpreted. It is parsed
		1062	+ and written as a string.
		1063	+*/
		1064	+class TINYXML2_LIB XMLDeclaration : public XMLNode
		1065	+{
		1066	+ friend class XMLDocument;
		1067	+public:
		1068	+ virtual XMLDeclaration* ToDeclaration() {
		1069	+ return this;
		1070	+ }
		1071	+ virtual const XMLDeclaration* ToDeclaration() const {
		1072	+ return this;
		1073	+ }
		1074	+
		1075	+ virtual bool Accept( XMLVisitor* visitor ) const;
		1076	+
		1077	+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
		1078	+ virtual bool ShallowEqual( const XMLNode* compare ) const;
		1079	+
		1080	+protected:
		1081	+ XMLDeclaration( XMLDocument* doc );
		1082	+ virtual ~XMLDeclaration();
		1083	+
		1084	+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
		1085	+
		1086	+private:
		1087	+ XMLDeclaration( const XMLDeclaration& ); // not supported
		1088	+ XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
		1089	+};
		1090	+
		1091	+
		1092	+/** Any tag that TinyXML-2 doesn't recognize is saved as an
		1093	+ unknown. It is a tag of text, but should not be modified.
		1094	+ It will be written back to the XML, unchanged, when the file
		1095	+ is saved.
		1096	+
		1097	+ DTD tags get thrown into XMLUnknowns.
		1098	+*/
		1099	+class TINYXML2_LIB XMLUnknown : public XMLNode
		1100	+{
		1101	+ friend class XMLDocument;
		1102	+public:
		1103	+ virtual XMLUnknown* ToUnknown() {
		1104	+ return this;
		1105	+ }
		1106	+ virtual const XMLUnknown* ToUnknown() const {
		1107	+ return this;
		1108	+ }
		1109	+
		1110	+ virtual bool Accept( XMLVisitor* visitor ) const;
		1111	+
		1112	+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
		1113	+ virtual bool ShallowEqual( const XMLNode* compare ) const;
		1114	+
		1115	+protected:
		1116	+ XMLUnknown( XMLDocument* doc );
		1117	+ virtual ~XMLUnknown();
		1118	+
		1119	+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
		1120	+
		1121	+private:
		1122	+ XMLUnknown( const XMLUnknown& ); // not supported
		1123	+ XMLUnknown& operator=( const XMLUnknown& ); // not supported
		1124	+};
		1125	+
		1126	+
		1127	+
		1128	+/** An attribute is a name-value pair. Elements have an arbitrary
		1129	+ number of attributes, each with a unique name.
		1130	+
		1131	+ @note The attributes are not XMLNodes. You may only query the
		1132	+ Next() attribute in a list.
		1133	+*/
		1134	+class TINYXML2_LIB XMLAttribute
		1135	+{
		1136	+ friend class XMLElement;
		1137	+public:
		1138	+ /// The name of the attribute.
		1139	+ const char* Name() const;
		1140	+
		1141	+ /// The value of the attribute.
		1142	+ const char* Value() const;
		1143	+
		1144	+ /// Gets the line number the attribute is in, if the document was parsed from a file.
		1145	+ int GetLineNum() const { return _parseLineNum; }
		1146	+
		1147	+ /// The next attribute in the list.
		1148	+ const XMLAttribute* Next() const {
		1149	+ return _next;
		1150	+ }
		1151	+
		1152	+ /** IntValue interprets the attribute as an integer, and returns the value.
		1153	+ If the value isn't an integer, 0 will be returned. There is no error checking;
		1154	+ use QueryIntValue() if you need error checking.
		1155	+ */
		1156	+ int IntValue() const {
		1157	+ int i = 0;
		1158	+ QueryIntValue(&i);
		1159	+ return i;
		1160	+ }
		1161	+
		1162	+ int64_t Int64Value() const {
		1163	+ int64_t i = 0;
		1164	+ QueryInt64Value(&i);
		1165	+ return i;
		1166	+ }
		1167	+
		1168	+ /// Query as an unsigned integer. See IntValue()
		1169	+ unsigned UnsignedValue() const {
		1170	+ unsigned i=0;
		1171	+ QueryUnsignedValue( &i );
		1172	+ return i;
		1173	+ }
		1174	+ /// Query as a boolean. See IntValue()
		1175	+ bool BoolValue() const {
		1176	+ bool b=false;
		1177	+ QueryBoolValue( &b );
		1178	+ return b;
		1179	+ }
		1180	+ /// Query as a double. See IntValue()
		1181	+ double DoubleValue() const {
		1182	+ double d=0;
		1183	+ QueryDoubleValue( &d );
		1184	+ return d;
		1185	+ }
		1186	+ /// Query as a float. See IntValue()
		1187	+ float FloatValue() const {
		1188	+ float f=0;
		1189	+ QueryFloatValue( &f );
		1190	+ return f;
		1191	+ }
		1192	+
		1193	+ /** QueryIntValue interprets the attribute as an integer, and returns the value
		1194	+ in the provided parameter. The function will return XML_SUCCESS on success,
		1195	+ and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
		1196	+ */
		1197	+ XMLError QueryIntValue( int* value ) const;
		1198	+ /// See QueryIntValue
		1199	+ XMLError QueryUnsignedValue( unsigned int* value ) const;
		1200	+ /// See QueryIntValue
		1201	+ XMLError QueryInt64Value(int64_t* value) const;
		1202	+ /// See QueryIntValue
		1203	+ XMLError QueryBoolValue( bool* value ) const;
		1204	+ /// See QueryIntValue
		1205	+ XMLError QueryDoubleValue( double* value ) const;
		1206	+ /// See QueryIntValue
		1207	+ XMLError QueryFloatValue( float* value ) const;
		1208	+
		1209	+ /// Set the attribute to a string value.
		1210	+ void SetAttribute( const char* value );
		1211	+ /// Set the attribute to value.
		1212	+ void SetAttribute( int value );
		1213	+ /// Set the attribute to value.
		1214	+ void SetAttribute( unsigned value );
		1215	+ /// Set the attribute to value.
		1216	+ void SetAttribute(int64_t value);
		1217	+ /// Set the attribute to value.
		1218	+ void SetAttribute( bool value );
		1219	+ /// Set the attribute to value.
		1220	+ void SetAttribute( double value );
		1221	+ /// Set the attribute to value.
		1222	+ void SetAttribute( float value );
		1223	+
		1224	+private:
		1225	+ enum { BUF_SIZE = 200 };
		1226	+
		1227	+ XMLAttribute() : _name(), _value(),_parseLineNum( 0 ), _next( 0 ), _memPool( 0 ) {}
		1228	+ virtual ~XMLAttribute() {}
		1229	+
		1230	+ XMLAttribute( const XMLAttribute& ); // not supported
		1231	+ void operator=( const XMLAttribute& ); // not supported
		1232	+ void SetName( const char* name );
		1233	+
		1234	+ char* ParseDeep( char* p, bool processEntities, int* curLineNumPtr );
		1235	+
		1236	+ mutable StrPair _name;
		1237	+ mutable StrPair _value;
		1238	+ int _parseLineNum;
		1239	+ XMLAttribute* _next;
		1240	+ MemPool* _memPool;
		1241	+};
		1242	+
		1243	+
		1244	+/** The element is a container class. It has a value, the element name,
		1245	+ and can contain other elements, text, comments, and unknowns.
		1246	+ Elements also contain an arbitrary number of attributes.
		1247	+*/
		1248	+class TINYXML2_LIB XMLElement : public XMLNode
		1249	+{
		1250	+ friend class XMLDocument;
		1251	+public:
		1252	+ /// Get the name of an element (which is the Value() of the node.)
		1253	+ const char* Name() const {
		1254	+ return Value();
		1255	+ }
		1256	+ /// Set the name of the element.
		1257	+ void SetName( const char* str, bool staticMem=false ) {
		1258	+ SetValue( str, staticMem );
		1259	+ }
		1260	+
		1261	+ virtual XMLElement* ToElement() {
		1262	+ return this;
		1263	+ }
		1264	+ virtual const XMLElement* ToElement() const {
		1265	+ return this;
		1266	+ }
		1267	+ virtual bool Accept( XMLVisitor* visitor ) const;
		1268	+
		1269	+ /** Given an attribute name, Attribute() returns the value
		1270	+ for the attribute of that name, or null if none
		1271	+ exists. For example:
		1272	+
		1273	+ @verbatim
		1274	+ const char* value = ele->Attribute( "foo" );
		1275	+ @endverbatim
		1276	+
		1277	+ The 'value' parameter is normally null. However, if specified,
		1278	+ the attribute will only be returned if the 'name' and 'value'
		1279	+ match. This allow you to write code:
		1280	+
		1281	+ @verbatim
		1282	+ if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
		1283	+ @endverbatim
		1284	+
		1285	+ rather than:
		1286	+ @verbatim
		1287	+ if ( ele->Attribute( "foo" ) ) {
		1288	+ if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
		1289	+ }
		1290	+ @endverbatim
		1291	+ */
		1292	+ const char* Attribute( const char* name, const char* value=0 ) const;
		1293	+
		1294	+ /** Given an attribute name, IntAttribute() returns the value
		1295	+ of the attribute interpreted as an integer. The default
		1296	+ value will be returned if the attribute isn't present,
		1297	+ or if there is an error. (For a method with error
		1298	+ checking, see QueryIntAttribute()).
		1299	+ */
		1300	+ int IntAttribute(const char* name, int defaultValue = 0) const;
		1301	+ /// See IntAttribute()
		1302	+ unsigned UnsignedAttribute(const char* name, unsigned defaultValue = 0) const;
		1303	+ /// See IntAttribute()
		1304	+ int64_t Int64Attribute(const char* name, int64_t defaultValue = 0) const;
		1305	+ /// See IntAttribute()
		1306	+ bool BoolAttribute(const char* name, bool defaultValue = false) const;
		1307	+ /// See IntAttribute()
		1308	+ double DoubleAttribute(const char* name, double defaultValue = 0) const;
		1309	+ /// See IntAttribute()
		1310	+ float FloatAttribute(const char* name, float defaultValue = 0) const;
		1311	+
		1312	+ /** Given an attribute name, QueryIntAttribute() returns
		1313	+ XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
		1314	+ can't be performed, or XML_NO_ATTRIBUTE if the attribute
		1315	+ doesn't exist. If successful, the result of the conversion
		1316	+ will be written to 'value'. If not successful, nothing will
		1317	+ be written to 'value'. This allows you to provide default
		1318	+ value:
		1319	+
		1320	+ @verbatim
		1321	+ int value = 10;
		1322	+ QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
		1323	+ @endverbatim
		1324	+ */
		1325	+ XMLError QueryIntAttribute( const char* name, int* value ) const {
		1326	+ const XMLAttribute* a = FindAttribute( name );
		1327	+ if ( !a ) {
		1328	+ return XML_NO_ATTRIBUTE;
		1329	+ }
		1330	+ return a->QueryIntValue( value );
		1331	+ }
		1332	+
		1333	+ /// See QueryIntAttribute()
		1334	+ XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
		1335	+ const XMLAttribute* a = FindAttribute( name );
		1336	+ if ( !a ) {
		1337	+ return XML_NO_ATTRIBUTE;
		1338	+ }
		1339	+ return a->QueryUnsignedValue( value );
		1340	+ }
		1341	+
		1342	+ /// See QueryIntAttribute()
		1343	+ XMLError QueryInt64Attribute(const char* name, int64_t* value) const {
		1344	+ const XMLAttribute* a = FindAttribute(name);
		1345	+ if (!a) {
		1346	+ return XML_NO_ATTRIBUTE;
		1347	+ }
		1348	+ return a->QueryInt64Value(value);
		1349	+ }
		1350	+
		1351	+ /// See QueryIntAttribute()
		1352	+ XMLError QueryBoolAttribute( const char* name, bool* value ) const {
		1353	+ const XMLAttribute* a = FindAttribute( name );
		1354	+ if ( !a ) {
		1355	+ return XML_NO_ATTRIBUTE;
		1356	+ }
		1357	+ return a->QueryBoolValue( value );
		1358	+ }
		1359	+ /// See QueryIntAttribute()
		1360	+ XMLError QueryDoubleAttribute( const char* name, double* value ) const {
		1361	+ const XMLAttribute* a = FindAttribute( name );
		1362	+ if ( !a ) {
		1363	+ return XML_NO_ATTRIBUTE;
		1364	+ }
		1365	+ return a->QueryDoubleValue( value );
		1366	+ }
		1367	+ /// See QueryIntAttribute()
		1368	+ XMLError QueryFloatAttribute( const char* name, float* value ) const {
		1369	+ const XMLAttribute* a = FindAttribute( name );
		1370	+ if ( !a ) {
		1371	+ return XML_NO_ATTRIBUTE;
		1372	+ }
		1373	+ return a->QueryFloatValue( value );
		1374	+ }
		1375	+
		1376	+ /// See QueryIntAttribute()
		1377	+ XMLError QueryStringAttribute(const char* name, const char** value) const {
		1378	+ const XMLAttribute* a = FindAttribute(name);
		1379	+ if (!a) {
		1380	+ return XML_NO_ATTRIBUTE;
		1381	+ }
		1382	+ *value = a->Value();
		1383	+ return XML_SUCCESS;
		1384	+ }
		1385	+
		1386	+
		1387	+
		1388	+ /** Given an attribute name, QueryAttribute() returns
		1389	+ XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
		1390	+ can't be performed, or XML_NO_ATTRIBUTE if the attribute
		1391	+ doesn't exist. It is overloaded for the primitive types,
		1392	+ and is a generally more convenient replacement of
		1393	+ QueryIntAttribute() and related functions.
		1394	+
		1395	+ If successful, the result of the conversion
		1396	+ will be written to 'value'. If not successful, nothing will
		1397	+ be written to 'value'. This allows you to provide default
		1398	+ value:
		1399	+
		1400	+ @verbatim
		1401	+ int value = 10;
		1402	+ QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
		1403	+ @endverbatim
		1404	+ */
		1405	+ int QueryAttribute( const char* name, int* value ) const {
		1406	+ return QueryIntAttribute( name, value );
		1407	+ }
		1408	+
		1409	+ int QueryAttribute( const char* name, unsigned int* value ) const {
		1410	+ return QueryUnsignedAttribute( name, value );
		1411	+ }
		1412	+
		1413	+ int QueryAttribute(const char* name, int64_t* value) const {
		1414	+ return QueryInt64Attribute(name, value);
		1415	+ }
		1416	+
		1417	+ int QueryAttribute( const char* name, bool* value ) const {
		1418	+ return QueryBoolAttribute( name, value );
		1419	+ }
		1420	+
		1421	+ int QueryAttribute( const char* name, double* value ) const {
		1422	+ return QueryDoubleAttribute( name, value );
		1423	+ }
		1424	+
		1425	+ int QueryAttribute( const char* name, float* value ) const {
		1426	+ return QueryFloatAttribute( name, value );
		1427	+ }
		1428	+
		1429	+ /// Sets the named attribute to value.
		1430	+ void SetAttribute( const char* name, const char* value ) {
		1431	+ XMLAttribute* a = FindOrCreateAttribute( name );
		1432	+ a->SetAttribute( value );
		1433	+ }
		1434	+ /// Sets the named attribute to value.
		1435	+ void SetAttribute( const char* name, int value ) {
		1436	+ XMLAttribute* a = FindOrCreateAttribute( name );
		1437	+ a->SetAttribute( value );
		1438	+ }
		1439	+ /// Sets the named attribute to value.
		1440	+ void SetAttribute( const char* name, unsigned value ) {
		1441	+ XMLAttribute* a = FindOrCreateAttribute( name );
		1442	+ a->SetAttribute( value );
		1443	+ }
		1444	+
		1445	+ /// Sets the named attribute to value.
		1446	+ void SetAttribute(const char* name, int64_t value) {
		1447	+ XMLAttribute* a = FindOrCreateAttribute(name);
		1448	+ a->SetAttribute(value);
		1449	+ }
		1450	+
		1451	+ /// Sets the named attribute to value.
		1452	+ void SetAttribute( const char* name, bool value ) {
		1453	+ XMLAttribute* a = FindOrCreateAttribute( name );
		1454	+ a->SetAttribute( value );
		1455	+ }
		1456	+ /// Sets the named attribute to value.
		1457	+ void SetAttribute( const char* name, double value ) {
		1458	+ XMLAttribute* a = FindOrCreateAttribute( name );
		1459	+ a->SetAttribute( value );
		1460	+ }
		1461	+ /// Sets the named attribute to value.
		1462	+ void SetAttribute( const char* name, float value ) {
		1463	+ XMLAttribute* a = FindOrCreateAttribute( name );
		1464	+ a->SetAttribute( value );
		1465	+ }
		1466	+
		1467	+ /**
		1468	+ Delete an attribute.
		1469	+ */
		1470	+ void DeleteAttribute( const char* name );
		1471	+
		1472	+ /// Return the first attribute in the list.
		1473	+ const XMLAttribute* FirstAttribute() const {
		1474	+ return _rootAttribute;
		1475	+ }
		1476	+ /// Query a specific attribute in the list.
		1477	+ const XMLAttribute* FindAttribute( const char* name ) const;
		1478	+
		1479	+ /** Convenience function for easy access to the text inside an element. Although easy
		1480	+ and concise, GetText() is limited compared to getting the XMLText child
		1481	+ and accessing it directly.
		1482	+
		1483	+ If the first child of 'this' is a XMLText, the GetText()
		1484	+ returns the character string of the Text node, else null is returned.
		1485	+
		1486	+ This is a convenient method for getting the text of simple contained text:
		1487	+ @verbatim
		1488	+ <foo>This is text</foo>
		1489	+ const char* str = fooElement->GetText();
		1490	+ @endverbatim
		1491	+
		1492	+ 'str' will be a pointer to "This is text".
		1493	+
		1494	+ Note that this function can be misleading. If the element foo was created from
		1495	+ this XML:
		1496	+ @verbatim
		1497	+ <foo><b>This is text</b></foo>
		1498	+ @endverbatim
		1499	+
		1500	+ then the value of str would be null. The first child node isn't a text node, it is
		1501	+ another element. From this XML:
		1502	+ @verbatim
		1503	+ <foo>This is <b>text</b></foo>
		1504	+ @endverbatim
		1505	+ GetText() will return "This is ".
		1506	+ */
		1507	+ const char* GetText() const;
		1508	+
		1509	+ /** Convenience function for easy access to the text inside an element. Although easy
		1510	+ and concise, SetText() is limited compared to creating an XMLText child
		1511	+ and mutating it directly.
		1512	+
		1513	+ If the first child of 'this' is a XMLText, SetText() sets its value to
		1514	+ the given string, otherwise it will create a first child that is an XMLText.
		1515	+
		1516	+ This is a convenient method for setting the text of simple contained text:
		1517	+ @verbatim
		1518	+ <foo>This is text</foo>
		1519	+ fooElement->SetText( "Hullaballoo!" );
		1520	+ <foo>Hullaballoo!</foo>
		1521	+ @endverbatim
		1522	+
		1523	+ Note that this function can be misleading. If the element foo was created from
		1524	+ this XML:
		1525	+ @verbatim
		1526	+ <foo><b>This is text</b></foo>
		1527	+ @endverbatim
		1528	+
		1529	+ then it will not change "This is text", but rather prefix it with a text element:
		1530	+ @verbatim
		1531	+ <foo>Hullaballoo!<b>This is text</b></foo>
		1532	+ @endverbatim
		1533	+
		1534	+ For this XML:
		1535	+ @verbatim
		1536	+ <foo />
		1537	+ @endverbatim
		1538	+ SetText() will generate
		1539	+ @verbatim
		1540	+ <foo>Hullaballoo!</foo>
		1541	+ @endverbatim
		1542	+ */
		1543	+ void SetText( const char* inText );
		1544	+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
		1545	+ void SetText( int value );
		1546	+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
		1547	+ void SetText( unsigned value );
		1548	+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
		1549	+ void SetText(int64_t value);
		1550	+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
		1551	+ void SetText( bool value );
		1552	+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
		1553	+ void SetText( double value );
		1554	+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
		1555	+ void SetText( float value );
		1556	+
		1557	+ /**
		1558	+ Convenience method to query the value of a child text node. This is probably best
		1559	+ shown by example. Given you have a document is this form:
		1560	+ @verbatim
		1561	+ <point>
		1562	+ <x>1</x>
		1563	+ <y>1.4</y>
		1564	+ </point>
		1565	+ @endverbatim
		1566	+
		1567	+ The QueryIntText() and similar functions provide a safe and easier way to get to the
		1568	+ "value" of x and y.
		1569	+
		1570	+ @verbatim
		1571	+ int x = 0;
		1572	+ float y = 0; // types of x and y are contrived for example
		1573	+ const XMLElement* xElement = pointElement->FirstChildElement( "x" );
		1574	+ const XMLElement* yElement = pointElement->FirstChildElement( "y" );
		1575	+ xElement->QueryIntText( &x );
		1576	+ yElement->QueryFloatText( &y );
		1577	+ @endverbatim
		1578	+
		1579	+ @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
		1580	+ to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
		1581	+
		1582	+ */
		1583	+ XMLError QueryIntText( int* ival ) const;
		1584	+ /// See QueryIntText()
		1585	+ XMLError QueryUnsignedText( unsigned* uval ) const;
		1586	+ /// See QueryIntText()
		1587	+ XMLError QueryInt64Text(int64_t* uval) const;
		1588	+ /// See QueryIntText()
		1589	+ XMLError QueryBoolText( bool* bval ) const;
		1590	+ /// See QueryIntText()
		1591	+ XMLError QueryDoubleText( double* dval ) const;
		1592	+ /// See QueryIntText()
		1593	+ XMLError QueryFloatText( float* fval ) const;
		1594	+
		1595	+ int IntText(int defaultValue = 0) const;
		1596	+
		1597	+ /// See QueryIntText()
		1598	+ unsigned UnsignedText(unsigned defaultValue = 0) const;
		1599	+ /// See QueryIntText()
		1600	+ int64_t Int64Text(int64_t defaultValue = 0) const;
		1601	+ /// See QueryIntText()
		1602	+ bool BoolText(bool defaultValue = false) const;
		1603	+ /// See QueryIntText()
		1604	+ double DoubleText(double defaultValue = 0) const;
		1605	+ /// See QueryIntText()
		1606	+ float FloatText(float defaultValue = 0) const;
		1607	+
		1608	+ // internal:
		1609	+ enum ElementClosingType {
		1610	+ OPEN, // <foo>
		1611	+ CLOSED, // <foo/>
		1612	+ CLOSING // </foo>
		1613	+ };
		1614	+ ElementClosingType ClosingType() const {
		1615	+ return _closingType;
		1616	+ }
		1617	+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
		1618	+ virtual bool ShallowEqual( const XMLNode* compare ) const;
		1619	+
		1620	+protected:
		1621	+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
		1622	+
		1623	+private:
		1624	+ XMLElement( XMLDocument* doc );
		1625	+ virtual ~XMLElement();
		1626	+ XMLElement( const XMLElement& ); // not supported
		1627	+ void operator=( const XMLElement& ); // not supported
		1628	+
		1629	+ XMLAttribute* FindAttribute( const char* name ) {
		1630	+ return const_cast<XMLAttribute>(const_cast<const XMLElement>(this)->FindAttribute( name ));
		1631	+ }
		1632	+ XMLAttribute* FindOrCreateAttribute( const char* name );
		1633	+ //void LinkAttribute( XMLAttribute* attrib );
		1634	+ char* ParseAttributes( char* p, int* curLineNumPtr );
		1635	+ static void DeleteAttribute( XMLAttribute* attribute );
		1636	+ XMLAttribute* CreateAttribute();
		1637	+
		1638	+ enum { BUF_SIZE = 200 };
		1639	+ ElementClosingType _closingType;
		1640	+ // The attribute list is ordered; there is no 'lastAttribute'
		1641	+ // because the list needs to be scanned for dupes before adding
		1642	+ // a new attribute.
		1643	+ XMLAttribute* _rootAttribute;
		1644	+};
		1645	+
		1646	+
		1647	+enum Whitespace {
		1648	+ PRESERVE_WHITESPACE,
		1649	+ COLLAPSE_WHITESPACE
		1650	+};
		1651	+
		1652	+
		1653	+/** A Document binds together all the functionality.
		1654	+ It can be saved, loaded, and printed to the screen.
		1655	+ All Nodes are connected and allocated to a Document.
		1656	+ If the Document is deleted, all its Nodes are also deleted.
		1657	+*/
		1658	+class TINYXML2_LIB XMLDocument : public XMLNode
		1659	+{
		1660	+ friend class XMLElement;
		1661	+ // Gives access to SetError and Push/PopDepth, but over-access for everything else.
		1662	+ // Wishing C++ had "internal" scope.
		1663	+ friend class XMLNode;
		1664	+ friend class XMLText;
		1665	+ friend class XMLComment;
		1666	+ friend class XMLDeclaration;
		1667	+ friend class XMLUnknown;
		1668	+public:
		1669	+ /// constructor
		1670	+ XMLDocument( bool processEntities = true, Whitespace whitespaceMode = PRESERVE_WHITESPACE );
		1671	+ ~XMLDocument();
		1672	+
		1673	+ virtual XMLDocument* ToDocument() {
		1674	+ TIXMLASSERT( this == _document );
		1675	+ return this;
		1676	+ }
		1677	+ virtual const XMLDocument* ToDocument() const {
		1678	+ TIXMLASSERT( this == _document );
		1679	+ return this;
		1680	+ }
		1681	+
		1682	+ /**
		1683	+ Parse an XML file from a character string.
		1684	+ Returns XML_SUCCESS (0) on success, or
		1685	+ an errorID.
		1686	+
		1687	+ You may optionally pass in the 'nBytes', which is
		1688	+ the number of bytes which will be parsed. If not
		1689	+ specified, TinyXML-2 will assume 'xml' points to a
		1690	+ null terminated string.
		1691	+ */
		1692	+ XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
		1693	+
		1694	+ /**
		1695	+ Load an XML file from disk.
		1696	+ Returns XML_SUCCESS (0) on success, or
		1697	+ an errorID.
		1698	+ */
		1699	+ XMLError LoadFile( const char* filename );
		1700	+
		1701	+ /**
		1702	+ Load an XML file from disk. You are responsible
		1703	+ for providing and closing the FILE*.
		1704	+
		1705	+ NOTE: The file should be opened as binary ("rb")
		1706	+ not text in order for TinyXML-2 to correctly
		1707	+ do newline normalization.
		1708	+
		1709	+ Returns XML_SUCCESS (0) on success, or
		1710	+ an errorID.
		1711	+ */
		1712	+ XMLError LoadFile( FILE* );
		1713	+
		1714	+ /**
		1715	+ Save the XML file to disk.
		1716	+ Returns XML_SUCCESS (0) on success, or
		1717	+ an errorID.
		1718	+ */
		1719	+ XMLError SaveFile( const char* filename, bool compact = false );
		1720	+
		1721	+ /**
		1722	+ Save the XML file to disk. You are responsible
		1723	+ for providing and closing the FILE*.
		1724	+
		1725	+ Returns XML_SUCCESS (0) on success, or
		1726	+ an errorID.
		1727	+ */
		1728	+ XMLError SaveFile( FILE* fp, bool compact = false );
		1729	+
		1730	+ bool ProcessEntities() const {
		1731	+ return _processEntities;
		1732	+ }
		1733	+ Whitespace WhitespaceMode() const {
		1734	+ return _whitespaceMode;
		1735	+ }
		1736	+
		1737	+ /**
		1738	+ Returns true if this document has a leading Byte Order Mark of UTF8.
		1739	+ */
		1740	+ bool HasBOM() const {
		1741	+ return _writeBOM;
		1742	+ }
		1743	+ /** Sets whether to write the BOM when writing the file.
		1744	+ */
		1745	+ void SetBOM( bool useBOM ) {
		1746	+ _writeBOM = useBOM;
		1747	+ }
		1748	+
		1749	+ /** Return the root element of DOM. Equivalent to FirstChildElement().
		1750	+ To get the first node, use FirstChild().
		1751	+ */
		1752	+ XMLElement* RootElement() {
		1753	+ return FirstChildElement();
		1754	+ }
		1755	+ const XMLElement* RootElement() const {
		1756	+ return FirstChildElement();
		1757	+ }
		1758	+
		1759	+ /** Print the Document. If the Printer is not provided, it will
		1760	+ print to stdout. If you provide Printer, this can print to a file:
		1761	+ @verbatim
		1762	+ XMLPrinter printer( fp );
		1763	+ doc.Print( &printer );
		1764	+ @endverbatim
		1765	+
		1766	+ Or you can use a printer to print to memory:
		1767	+ @verbatim
		1768	+ XMLPrinter printer;
		1769	+ doc.Print( &printer );
		1770	+ // printer.CStr() has a const char* to the XML
		1771	+ @endverbatim
		1772	+ */
		1773	+ void Print( XMLPrinter* streamer=0 ) const;
		1774	+ virtual bool Accept( XMLVisitor* visitor ) const;
		1775	+
		1776	+ /**
		1777	+ Create a new Element associated with
		1778	+ this Document. The memory for the Element
		1779	+ is managed by the Document.
		1780	+ */
		1781	+ XMLElement* NewElement( const char* name );
		1782	+ /**
		1783	+ Create a new Comment associated with
		1784	+ this Document. The memory for the Comment
		1785	+ is managed by the Document.
		1786	+ */
		1787	+ XMLComment* NewComment( const char* comment );
		1788	+ /**
		1789	+ Create a new Text associated with
		1790	+ this Document. The memory for the Text
		1791	+ is managed by the Document.
		1792	+ */
		1793	+ XMLText* NewText( const char* text );
		1794	+ /**
		1795	+ Create a new Declaration associated with
		1796	+ this Document. The memory for the object
		1797	+ is managed by the Document.
		1798	+
		1799	+ If the 'text' param is null, the standard
		1800	+ declaration is used.:
		1801	+ @verbatim
		1802	+ <?xml version="1.0" encoding="UTF-8"?>
		1803	+ @endverbatim
		1804	+ */
		1805	+ XMLDeclaration* NewDeclaration( const char* text=0 );
		1806	+ /**
		1807	+ Create a new Unknown associated with
		1808	+ this Document. The memory for the object
		1809	+ is managed by the Document.
		1810	+ */
		1811	+ XMLUnknown* NewUnknown( const char* text );
		1812	+
		1813	+ /**
		1814	+ Delete a node associated with this document.
		1815	+ It will be unlinked from the DOM.
		1816	+ */
		1817	+ void DeleteNode( XMLNode* node );
		1818	+
		1819	+ void ClearError() {
		1820	+ SetError(XML_SUCCESS, 0, 0);
		1821	+ }
		1822	+
		1823	+ /// Return true if there was an error parsing the document.
		1824	+ bool Error() const {
		1825	+ return _errorID != XML_SUCCESS;
		1826	+ }
		1827	+ /// Return the errorID.
		1828	+ XMLError ErrorID() const {
		1829	+ return _errorID;
		1830	+ }
		1831	+ const char* ErrorName() const;
		1832	+ static const char* ErrorIDToName(XMLError errorID);
		1833	+
		1834	+ /** Returns a "long form" error description. A hopefully helpful
		1835	+ diagnostic with location, line number, and/or additional info.
		1836	+ */
		1837	+ const char* ErrorStr() const;
		1838	+
		1839	+ /// A (trivial) utility function that prints the ErrorStr() to stdout.
		1840	+ void PrintError() const;
		1841	+
		1842	+ /// Return the line where the error occured, or zero if unknown.
		1843	+ int ErrorLineNum() const
		1844	+ {
		1845	+ return _errorLineNum;
		1846	+ }
		1847	+
		1848	+ /// Clear the document, resetting it to the initial state.
		1849	+ void Clear();
		1850	+
		1851	+ /**
		1852	+ Copies this document to a target document.
		1853	+ The target will be completely cleared before the copy.
		1854	+ If you want to copy a sub-tree, see XMLNode::DeepClone().
		1855	+
		1856	+ NOTE: that the 'target' must be non-null.
		1857	+ */
		1858	+ void DeepCopy(XMLDocument* target) const;
		1859	+
		1860	+ // internal
		1861	+ char* Identify( char* p, XMLNode** node );
		1862	+
		1863	+ // internal
		1864	+ void MarkInUse(XMLNode*);
		1865	+
		1866	+ virtual XMLNode* ShallowClone( XMLDocument* /document/ ) const {
		1867	+ return 0;
		1868	+ }
		1869	+ virtual bool ShallowEqual( const XMLNode* /compare/ ) const {
		1870	+ return false;
		1871	+ }
		1872	+
		1873	+private:
		1874	+ XMLDocument( const XMLDocument& ); // not supported
		1875	+ void operator=( const XMLDocument& ); // not supported
		1876	+
		1877	+ bool _writeBOM;
		1878	+ bool _processEntities;
		1879	+ XMLError _errorID;
		1880	+ Whitespace _whitespaceMode;
		1881	+ mutable StrPair _errorStr;
		1882	+ int _errorLineNum;
		1883	+ char* _charBuffer;
		1884	+ int _parseCurLineNum;
		1885	+ int _parsingDepth;
		1886	+ // Memory tracking does add some overhead.
		1887	+ // However, the code assumes that you don't
		1888	+ // have a bunch of unlinked nodes around.
		1889	+ // Therefore it takes less memory to track
		1890	+ // in the document vs. a linked list in the XMLNode,
		1891	+ // and the performance is the same.
		1892	+ DynArray<XMLNode*, 10> _unlinked;
		1893	+
		1894	+ MemPoolT< sizeof(XMLElement) > _elementPool;
		1895	+ MemPoolT< sizeof(XMLAttribute) > _attributePool;
		1896	+ MemPoolT< sizeof(XMLText) > _textPool;
		1897	+ MemPoolT< sizeof(XMLComment) > _commentPool;
		1898	+
		1899	+ static const char* _errorNames[XML_ERROR_COUNT];
		1900	+
		1901	+ void Parse();
		1902	+
		1903	+ void SetError( XMLError error, int lineNum, const char* format, ... );
		1904	+
		1905	+ // Something of an obvious security hole, once it was discovered.
		1906	+ // Either an ill-formed XML or an excessively deep one can overflow
		1907	+ // the stack. Track stack depth, and error out if needed.
		1908	+ class DepthTracker {
		1909	+ public:
		1910	+ DepthTracker(XMLDocument * document) {
		1911	+ this->_document = document;
		1912	+ document->PushDepth();
		1913	+ }
		1914	+ ~DepthTracker() {
		1915	+ _document->PopDepth();
		1916	+ }
		1917	+ private:
		1918	+ XMLDocument * _document;
		1919	+ };
		1920	+ void PushDepth();
		1921	+ void PopDepth();
		1922	+
		1923	+ template<class NodeType, int PoolElementSize>
		1924	+ NodeType* CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool );
		1925	+};
		1926	+
		1927	+template<class NodeType, int PoolElementSize>
		1928	+inline NodeType* XMLDocument::CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool )
		1929	+{
		1930	+ TIXMLASSERT( sizeof( NodeType ) == PoolElementSize );
		1931	+ TIXMLASSERT( sizeof( NodeType ) == pool.ItemSize() );
		1932	+ NodeType* returnNode = new (pool.Alloc()) NodeType( this );
		1933	+ TIXMLASSERT( returnNode );
		1934	+ returnNode->_memPool = &pool;
		1935	+
		1936	+ _unlinked.Push(returnNode);
		1937	+ return returnNode;
		1938	+}
		1939	+
		1940	+/**
		1941	+ A XMLHandle is a class that wraps a node pointer with null checks; this is
		1942	+ an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
		1943	+ DOM structure. It is a separate utility class.
		1944	+
		1945	+ Take an example:
		1946	+ @verbatim
		1947	+ <Document>
		1948	+ <Element attributeA = "valueA">
		1949	+ <Child attributeB = "value1" />
		1950	+ <Child attributeB = "value2" />
		1951	+ </Element>
		1952	+ </Document>
		1953	+ @endverbatim
		1954	+
		1955	+ Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
		1956	+ easy to write a lot of code that looks like:
		1957	+
		1958	+ @verbatim
		1959	+ XMLElement* root = document.FirstChildElement( "Document" );
		1960	+ if ( root )
		1961	+ {
		1962	+ XMLElement* element = root->FirstChildElement( "Element" );
		1963	+ if ( element )
		1964	+ {
		1965	+ XMLElement* child = element->FirstChildElement( "Child" );
		1966	+ if ( child )
		1967	+ {
		1968	+ XMLElement* child2 = child->NextSiblingElement( "Child" );
		1969	+ if ( child2 )
		1970	+ {
		1971	+ // Finally do something useful.
		1972	+ @endverbatim
		1973	+
		1974	+ And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
		1975	+ of such code. A XMLHandle checks for null pointers so it is perfectly safe
		1976	+ and correct to use:
		1977	+
		1978	+ @verbatim
		1979	+ XMLHandle docHandle( &document );
		1980	+ XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
		1981	+ if ( child2 )
		1982	+ {
		1983	+ // do something useful
		1984	+ @endverbatim
		1985	+
		1986	+ Which is MUCH more concise and useful.
		1987	+
		1988	+ It is also safe to copy handles - internally they are nothing more than node pointers.
		1989	+ @verbatim
		1990	+ XMLHandle handleCopy = handle;
		1991	+ @endverbatim
		1992	+
		1993	+ See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
		1994	+*/
		1995	+class TINYXML2_LIB XMLHandle
		1996	+{
		1997	+public:
		1998	+ /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
		1999	+ XMLHandle( XMLNode* node ) : _node( node ) {
		2000	+ }
		2001	+ /// Create a handle from a node.
		2002	+ XMLHandle( XMLNode& node ) : _node( &node ) {
		2003	+ }
		2004	+ /// Copy constructor
		2005	+ XMLHandle( const XMLHandle& ref ) : _node( ref._node ) {
		2006	+ }
		2007	+ /// Assignment
		2008	+ XMLHandle& operator=( const XMLHandle& ref ) {
		2009	+ _node = ref._node;
		2010	+ return *this;
		2011	+ }
		2012	+
		2013	+ /// Get the first child of this handle.
		2014	+ XMLHandle FirstChild() {
		2015	+ return XMLHandle( _node ? _node->FirstChild() : 0 );
		2016	+ }
		2017	+ /// Get the first child element of this handle.
		2018	+ XMLHandle FirstChildElement( const char* name = 0 ) {
		2019	+ return XMLHandle( _node ? _node->FirstChildElement( name ) : 0 );
		2020	+ }
		2021	+ /// Get the last child of this handle.
		2022	+ XMLHandle LastChild() {
		2023	+ return XMLHandle( _node ? _node->LastChild() : 0 );
		2024	+ }
		2025	+ /// Get the last child element of this handle.
		2026	+ XMLHandle LastChildElement( const char* name = 0 ) {
		2027	+ return XMLHandle( _node ? _node->LastChildElement( name ) : 0 );
		2028	+ }
		2029	+ /// Get the previous sibling of this handle.
		2030	+ XMLHandle PreviousSibling() {
		2031	+ return XMLHandle( _node ? _node->PreviousSibling() : 0 );
		2032	+ }
		2033	+ /// Get the previous sibling element of this handle.
		2034	+ XMLHandle PreviousSiblingElement( const char* name = 0 ) {
		2035	+ return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
		2036	+ }
		2037	+ /// Get the next sibling of this handle.
		2038	+ XMLHandle NextSibling() {
		2039	+ return XMLHandle( _node ? _node->NextSibling() : 0 );
		2040	+ }
		2041	+ /// Get the next sibling element of this handle.
		2042	+ XMLHandle NextSiblingElement( const char* name = 0 ) {
		2043	+ return XMLHandle( _node ? _node->NextSiblingElement( name ) : 0 );
		2044	+ }
		2045	+
		2046	+ /// Safe cast to XMLNode. This can return null.
		2047	+ XMLNode* ToNode() {
		2048	+ return _node;
		2049	+ }
		2050	+ /// Safe cast to XMLElement. This can return null.
		2051	+ XMLElement* ToElement() {
		2052	+ return ( _node ? _node->ToElement() : 0 );
		2053	+ }
		2054	+ /// Safe cast to XMLText. This can return null.
		2055	+ XMLText* ToText() {
		2056	+ return ( _node ? _node->ToText() : 0 );
		2057	+ }
		2058	+ /// Safe cast to XMLUnknown. This can return null.
		2059	+ XMLUnknown* ToUnknown() {
		2060	+ return ( _node ? _node->ToUnknown() : 0 );
		2061	+ }
		2062	+ /// Safe cast to XMLDeclaration. This can return null.
		2063	+ XMLDeclaration* ToDeclaration() {
		2064	+ return ( _node ? _node->ToDeclaration() : 0 );
		2065	+ }
		2066	+
		2067	+private:
		2068	+ XMLNode* _node;
		2069	+};
		2070	+
		2071	+
		2072	+/**
		2073	+ A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
		2074	+ same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
		2075	+*/
		2076	+class TINYXML2_LIB XMLConstHandle
		2077	+{
		2078	+public:
		2079	+ XMLConstHandle( const XMLNode* node ) : _node( node ) {
		2080	+ }
		2081	+ XMLConstHandle( const XMLNode& node ) : _node( &node ) {
		2082	+ }
		2083	+ XMLConstHandle( const XMLConstHandle& ref ) : _node( ref._node ) {
		2084	+ }
		2085	+
		2086	+ XMLConstHandle& operator=( const XMLConstHandle& ref ) {
		2087	+ _node = ref._node;
		2088	+ return *this;
		2089	+ }
		2090	+
		2091	+ const XMLConstHandle FirstChild() const {
		2092	+ return XMLConstHandle( _node ? _node->FirstChild() : 0 );
		2093	+ }
		2094	+ const XMLConstHandle FirstChildElement( const char* name = 0 ) const {
		2095	+ return XMLConstHandle( _node ? _node->FirstChildElement( name ) : 0 );
		2096	+ }
		2097	+ const XMLConstHandle LastChild() const {
		2098	+ return XMLConstHandle( _node ? _node->LastChild() : 0 );
		2099	+ }
		2100	+ const XMLConstHandle LastChildElement( const char* name = 0 ) const {
		2101	+ return XMLConstHandle( _node ? _node->LastChildElement( name ) : 0 );
		2102	+ }
		2103	+ const XMLConstHandle PreviousSibling() const {
		2104	+ return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
		2105	+ }
		2106	+ const XMLConstHandle PreviousSiblingElement( const char* name = 0 ) const {
		2107	+ return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
		2108	+ }
		2109	+ const XMLConstHandle NextSibling() const {
		2110	+ return XMLConstHandle( _node ? _node->NextSibling() : 0 );
		2111	+ }
		2112	+ const XMLConstHandle NextSiblingElement( const char* name = 0 ) const {
		2113	+ return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : 0 );
		2114	+ }
		2115	+
		2116	+
		2117	+ const XMLNode* ToNode() const {
		2118	+ return _node;
		2119	+ }
		2120	+ const XMLElement* ToElement() const {
		2121	+ return ( _node ? _node->ToElement() : 0 );
		2122	+ }
		2123	+ const XMLText* ToText() const {
		2124	+ return ( _node ? _node->ToText() : 0 );
		2125	+ }
		2126	+ const XMLUnknown* ToUnknown() const {
		2127	+ return ( _node ? _node->ToUnknown() : 0 );
		2128	+ }
		2129	+ const XMLDeclaration* ToDeclaration() const {
		2130	+ return ( _node ? _node->ToDeclaration() : 0 );
		2131	+ }
		2132	+
		2133	+private:
		2134	+ const XMLNode* _node;
		2135	+};
		2136	+
		2137	+
		2138	+/**
		2139	+ Printing functionality. The XMLPrinter gives you more
		2140	+ options than the XMLDocument::Print() method.
		2141	+
		2142	+ It can:
		2143	+ -# Print to memory.
		2144	+ -# Print to a file you provide.
		2145	+ -# Print XML without a XMLDocument.
		2146	+
		2147	+ Print to Memory
		2148	+
		2149	+ @verbatim
		2150	+ XMLPrinter printer;
		2151	+ doc.Print( &printer );
		2152	+ SomeFunction( printer.CStr() );
		2153	+ @endverbatim
		2154	+
		2155	+ Print to a File
		2156	+
		2157	+ You provide the file pointer.
		2158	+ @verbatim
		2159	+ XMLPrinter printer( fp );
		2160	+ doc.Print( &printer );
		2161	+ @endverbatim
		2162	+
		2163	+ Print without a XMLDocument
		2164	+
		2165	+ When loading, an XML parser is very useful. However, sometimes
		2166	+ when saving, it just gets in the way. The code is often set up
		2167	+ for streaming, and constructing the DOM is just overhead.
		2168	+
		2169	+ The Printer supports the streaming case. The following code
		2170	+ prints out a trivially simple XML file without ever creating
		2171	+ an XML document.
		2172	+
		2173	+ @verbatim
		2174	+ XMLPrinter printer( fp );
		2175	+ printer.OpenElement( "foo" );
		2176	+ printer.PushAttribute( "foo", "bar" );
		2177	+ printer.CloseElement();
		2178	+ @endverbatim
		2179	+*/
		2180	+class TINYXML2_LIB XMLPrinter : public XMLVisitor
		2181	+{
		2182	+public:
		2183	+ /** Construct the printer. If the FILE* is specified,
		2184	+ this will print to the FILE. Else it will print
		2185	+ to memory, and the result is available in CStr().
		2186	+ If 'compact' is set to true, then output is created
		2187	+ with only required whitespace and newlines.
		2188	+ */
		2189	+ XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
		2190	+ virtual ~XMLPrinter() {}
		2191	+
		2192	+ /** If streaming, write the BOM and declaration. */
		2193	+ void PushHeader( bool writeBOM, bool writeDeclaration );
		2194	+ /** If streaming, start writing an element.
		2195	+ The element must be closed with CloseElement()
		2196	+ */
		2197	+ void OpenElement( const char* name, bool compactMode=false );
		2198	+ /// If streaming, add an attribute to an open element.
		2199	+ void PushAttribute( const char* name, const char* value );
		2200	+ void PushAttribute( const char* name, int value );
		2201	+ void PushAttribute( const char* name, unsigned value );
		2202	+ void PushAttribute(const char* name, int64_t value);
		2203	+ void PushAttribute( const char* name, bool value );
		2204	+ void PushAttribute( const char* name, double value );
		2205	+ /// If streaming, close the Element.
		2206	+ virtual void CloseElement( bool compactMode=false );
		2207	+
		2208	+ /// Add a text node.
		2209	+ void PushText( const char* text, bool cdata=false );
		2210	+ /// Add a text node from an integer.
		2211	+ void PushText( int value );
		2212	+ /// Add a text node from an unsigned.
		2213	+ void PushText( unsigned value );
		2214	+ /// Add a text node from an unsigned.
		2215	+ void PushText(int64_t value);
		2216	+ /// Add a text node from a bool.
		2217	+ void PushText( bool value );
		2218	+ /// Add a text node from a float.
		2219	+ void PushText( float value );
		2220	+ /// Add a text node from a double.
		2221	+ void PushText( double value );
		2222	+
		2223	+ /// Add a comment
		2224	+ void PushComment( const char* comment );
		2225	+
		2226	+ void PushDeclaration( const char* value );
		2227	+ void PushUnknown( const char* value );
		2228	+
		2229	+ virtual bool VisitEnter( const XMLDocument& /doc/ );
		2230	+ virtual bool VisitExit( const XMLDocument& /doc/ ) {
		2231	+ return true;
		2232	+ }
		2233	+
		2234	+ virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
		2235	+ virtual bool VisitExit( const XMLElement& element );
		2236	+
		2237	+ virtual bool Visit( const XMLText& text );
		2238	+ virtual bool Visit( const XMLComment& comment );
		2239	+ virtual bool Visit( const XMLDeclaration& declaration );
		2240	+ virtual bool Visit( const XMLUnknown& unknown );
		2241	+
		2242	+ /**
		2243	+ If in print to memory mode, return a pointer to
		2244	+ the XML file in memory.
		2245	+ */
		2246	+ const char* CStr() const {
		2247	+ return _buffer.Mem();
		2248	+ }
		2249	+ /**
		2250	+ If in print to memory mode, return the size
		2251	+ of the XML file in memory. (Note the size returned
		2252	+ includes the terminating null.)
		2253	+ */
		2254	+ int CStrSize() const {
		2255	+ return _buffer.Size();
		2256	+ }
		2257	+ /**
		2258	+ If in print to memory mode, reset the buffer to the
		2259	+ beginning.
		2260	+ */
		2261	+ void ClearBuffer() {
		2262	+ _buffer.Clear();
		2263	+ _buffer.Push(0);
		2264	+ _firstElement = true;
		2265	+ }
		2266	+
		2267	+protected:
		2268	+ virtual bool CompactMode( const XMLElement& ) { return _compactMode; }
		2269	+
		2270	+ /** Prints out the space before an element. You may override to change
		2271	+ the space and tabs used. A PrintSpace() override should call Print().
		2272	+ */
		2273	+ virtual void PrintSpace( int depth );
		2274	+ void Print( const char* format, ... );
		2275	+ void Write( const char* data, size_t size );
		2276	+ inline void Write( const char* data ) { Write( data, strlen( data ) ); }
		2277	+ void Putc( char ch );
		2278	+
		2279	+ void SealElementIfJustOpened();
		2280	+ bool _elementJustOpened;
		2281	+ DynArray< const char*, 10 > _stack;
		2282	+
		2283	+private:
		2284	+ void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
		2285	+
		2286	+ bool _firstElement;
		2287	+ FILE* _fp;
		2288	+ int _depth;
		2289	+ int _textDepth;
		2290	+ bool _processEntities;
		2291	+ bool _compactMode;
		2292	+
		2293	+ enum {
		2294	+ ENTITY_RANGE = 64,
		2295	+ BUF_SIZE = 200
		2296	+ };
		2297	+ bool _entityFlag[ENTITY_RANGE];
		2298	+ bool _restrictedEntityFlag[ENTITY_RANGE];
		2299	+
		2300	+ DynArray< char, 20 > _buffer;
		2301	+
		2302	+ // Prohibit cloning, intentionally not implemented
		2303	+ XMLPrinter( const XMLPrinter& );
		2304	+ XMLPrinter& operator=( const XMLPrinter& );
		2305	+};
		2306	+
		2307	+
		2308	+} // tinyxml2
		2309	+
		2310	+#if defined(_MSC_VER)
		2311	+# pragma warning(pop)
		2312	+#endif
		2313	+
		2314	+#endif // TINYXML2_INCLUDED