开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
AtmiBrokerEnvXml.cxx
资源名称：blacktie-2.0.0.M3-src.zip　[点击查看]
上传用户：xfwatch
上传日期：2020-12-14
资源大小：872k
文件大小：24k
源码类别：

中间件编程

开发平台：

Java

AtmiBrokerEnvXml.cxx：源码内容
  1. /*
  2.  * JBoss, Home of Professional Open Source
  3.  * Copyright 2008, Red Hat, Inc., and others contributors as indicated
  4.  * by the @authors tag. All rights reserved.
  5.  * See the copyright.txt in the distribution for a
  6.  * full listing of individual contributors.
  7.  * This copyrighted material is made available to anyone wishing to use,
  8.  * modify, copy, or redistribute it subject to the terms and conditions
  9.  * of the GNU Lesser General Public License, v. 2.1.
  10.  * This program is distributed in the hope that it will be useful, but WITHOUT A
  11.  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  12.  * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
  13.  * You should have received a copy of the GNU Lesser General Public License,
  14.  * v.2.1 along with this distribution; if not, write to the Free Software
  15.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  16.  * MA  02110-1301, USA.
  17.  */
  19. #include <sys/stat.h>
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include <iostream>
  23. #include <stdexcept>
  25. #include "expat.h"
  27. #include "AtmiBrokerEnv.h"
  28. #include "AtmiBrokerEnvXml.h"
  29. #include "XsdValidator.h"
  31. #include "log4cxx/logger.h"
  32. #include "ace/ACE.h"
  33. #include "ace/OS_NS_stdlib.h"
  34. #include "ace/OS_NS_stdio.h"
  35. #include "ace/OS_NS_string.h"
  36. #include "ace/Default_Constants.h"
  38. log4cxx::LoggerPtr loggerAtmiBrokerEnvXml(log4cxx::Logger::getLogger(
  39. "AtmiBrokerEnvXml"));
  40. xarm_config_t * xarmp = 0;
  41. ServersInfo servers;
  42. ServiceInfo service;
  43. Buffers buffers;
  45. OrbConfig orbConfig;
  46. MqConfig mqConfig;
  48. char domain[30];
  49. char* queue_name;
  50. char* transFactoryId;
  52. static char last_element[50];
  53. static char last_value[1024];
  55. static char element[50];
  56. static char value[1024];
  58. static int depth = 0;
  60. static int envVariableCount = 0;
  62. static bool processingXaResource = false;
  63. static bool processingEnvVariable = false;
  64. static char* configuration = NULL;
  65. static char* currentBufferName = NULL;
  67. static int MEM_CHAR_SIZE = sizeof(char);//1;
  68. static int MEM_LONG_SIZE = sizeof(long);//8;
  69. static int MEM_INT_SIZE = sizeof(int);//4;
  70. static int MEM_SHORT_SIZE = sizeof(short);//2;
  71. static int MEM_FLOAT_SIZE = sizeof(float);//INT_SIZE;
  72. static int MEM_DOUBLE_SIZE = sizeof(double);//LONG_SIZE;
  74. static int WIRE_CHAR_SIZE = 1;
  75. static int WIRE_LONG_SIZE = 8;
  76. static int WIRE_INT_SIZE = 4;
  77. static int WIRE_SHORT_SIZE = 2;
  78. static int WIRE_FLOAT_SIZE = 4;
  79. static int WIRE_DOUBLE_SIZE = 8;
  82. AtmiBrokerEnvXml::AtmiBrokerEnvXml() {
  83. depth = 0;
  84. envVariableCount = 0;
  86. processingXaResource = false;
  87. processingEnvVariable = false;
  88. currentBufferName = NULL;
  89. configuration = NULL;
  90. }
  92. AtmiBrokerEnvXml::~AtmiBrokerEnvXml() {
  93. }
  95. static int warnCnt = 0;
  96. static void warn(const char * reason) {
  97. if (warnCnt++ == 0)
  98. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml, (char*) reason);
  99. }
  101. /**
  102.  * Duplicate a value. If the value contains an expression of the for ${ENV}
  103.  * then ENV is interpreted as an environment variable and ${ENV} is replaced
  104.  * by its value (if ENV is not set it is replaced by null string).
  105.  *
  106.  * WARNING: only the first such occurence is expanded. TODO generalise the function
  107.  */
  108. static char * XMLCALL copy_value(const char *value) {
  109. char *s = (char *) strchr(value, '$');
  110. char *e;
  112. if (s && *(s + 1) == '{' && (e = (char *) strchr(s, '}'))) {
  113. size_t esz = e - s - 2;
  114. char *en = ACE::strndup(s + 2, esz);
  115. char *ev = ACE_OS::getenv(en); /* ACE_OS::getenv(en);*/
  116. char *pr = ACE::strndup(value, (s - value));
  117. size_t rsz;
  118. char *v;
  120. if (ev == NULL) {
  121. LOG4CXX_WARN(loggerAtmiBrokerEnvXml, (char*) "env variable is unset: " << en);
  122. ev = (char *) "";
  123. }
  125. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char *) "expanding env: "
  126. << (s + 2) << (char *) " and e=" << e << (char *) " and en="
  127. << en << (char *) " and pr=" << pr << (char *) " and ev=" << ev);
  128. e += 1;
  129. rsz = ACE_OS::strlen(pr) + ACE_OS::strlen(e) + ACE_OS::strlen(ev) + 1; /* add 1 for null terminator */
  130. v = (char *) malloc(rsz);
  132. ACE_OS::snprintf(v, rsz, "%s%s%s", pr, ev, e);
  133. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, value << (char*) " -> " << v);
  135. free(en);
  136. free(pr);
  138. return v;
  139. }
  141. return strdup(value);
  142. }
  144. static bool applicable_config(char *config, const char *attribute) {
  145. if (config == NULL || ACE_OS::strlen(config) == 0) {
  146. // see if it is set in the environment
  147. if ((config = ACE_OS::getenv("BLACKTIE_CONFIGURATION")) == 0)
  148. return false;
  149. }
  151. char * conf = copy_value(attribute);
  152. bool rtn = strcmp(conf, config);
  154. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "comparing " << conf
  155. << " with " << config);
  156. free(conf);
  158. return (rtn == 0);
  159. }
  161. static bool checkService(char* serverName, const char* serviceName) {
  162. for(unsigned int i = 0; i < servers.size(); i ++) {
  163. if(ACE_OS::strcmp(serverName, servers[i]->serverName) != 0) {
  164. for(unsigned int j = 0; j < servers[i]->serviceVector.size(); j ++) {
  165. if(ACE_OS::strcmp(serviceName, servers[i]->serviceVector[j].serviceName) == 0)
  166. return true;
  167. }
  168. }
  169. }
  170. return false;
  171. }
  173. static void XMLCALL startElement
  174. (void *userData, const char *name, const char **atts) {
  175. std::vector<envVar_t>* aEnvironmentStructPtr = (std::vector<envVar_t>*) userData;
  177. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "processing element " << name);
  178. if (strcmp(name, "ENVIRONMENT xmnls") == 0 || strcmp(name, "ENVIRONMENT") == 0) {
  179. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "starting to read");
  180. } else if (strcmp(name, "ORB") == 0) {
  181. for(int i = 0; atts[i]; i += 2) {
  182. if(strcmp(atts[i], "OPT") == 0) {
  183. orbConfig.opt = copy_value(atts[i+1]);
  184. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "set opt: " << orbConfig.opt);
  185. } else if(strcmp(atts[i], "TRANS_FACTORY_ID") == 0) {
  186. orbConfig.transactionFactoryName = copy_value(atts[i+1]);
  187. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "set tFN: " << orbConfig.transactionFactoryName);
  188. }
  189. }
  190. } else if (strcmp(name, "MQ") == 0) {
  191. for(int i = 0; atts[i]; i += 2) {
  192. if(strcmp(atts[i], "HOST") == 0) {
  193. mqConfig.host = copy_value(atts[i+1]);
  194. } else if(strcmp(atts[i], "PORT") == 0) {
  195. mqConfig.port = atoi(atts[i+1]);
  196. } else if(strcmp(atts[i], "USER") == 0) {
  197. mqConfig.user = copy_value(atts[i+1]);
  198. } else if(strcmp(atts[i], "PASSWORD") == 0) {
  199. mqConfig.pwd = copy_value(atts[i+1]);
  200. } else if(strcmp(atts[i], "DESTINATION_TIMEOUT") == 0) {
  201. mqConfig.destinationTimeout = atoi(atts[i+1]);
  202. } else if(strcmp(atts[i], "RECEIVE_TIMEOUT") == 0) {
  203. mqConfig.requestTimeout = atoi(atts[i+1]);
  204. } else if(strcmp(atts[i], "TIME_TO_LIVE") == 0) {
  205. mqConfig.timeToLive = atoi(atts[i+1]);
  206. }
  207. }
  208. } else if (strcmp(name, "SERVER") == 0) {
  209. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "processing SERVER");
  211. ServerInfo* server = new ServerInfo;
  212. if(atts != 0) {
  213. if(atts[0] && strcmp(atts[0], "name") == 0) {
  214. server->serverName = copy_value(atts[1]);
  215. } else {
  216. server->serverName = copy_value("default");
  217. }
  218. }
  220. servers.push_back(server);
  221. } else if (strcmp(name, "XA_RESOURCE") == 0) {
  222. if(strcmp(atts[0], "configuration") == 0 && applicable_config(configuration, atts[1])) {
  224. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "processing xaresource");
  225. processingXaResource = true;
  226. xarm_config_t *p;
  227. if ((p = (xarm_config_t *) malloc(sizeof(xarm_config_t))) == 0) {
  228. warnCnt = 0;
  229. warn("out of memory");
  230. } else {
  231. (void *) memset(p, 0, sizeof(xarm_config_t));
  233. if (xarmp == 0) {
  234. p->head = p;
  235. } else {
  236. xarmp->next = p;
  237. p->head = xarmp->head;
  238. }
  239. xarmp = p;
  240. }
  241. } else {
  242. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "CONFIGURATION NOT APPLICABLE FOR XA_RESOURCE: " << atts[1]);
  243. }
  244. } else if (strcmp(name, "ENV_VARIABLE") == 0) {
  245. if(atts != 0 && atts[0] && strcmp(atts[0], "configuration") == 0) {
  246. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "comparing" << atts[1] << " with " << configuration);
  247. if (strcmp(atts[1], configuration) == 0) {
  248. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "processing ENV_VARIABLE");
  249. processingEnvVariable = true;
  250. } else {
  251. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "CONFIGURATION NOT APPLICABLE FOR ENV_VARIABLE: " << atts[1]);
  252. }
  253. } else {
  254. processingEnvVariable = true;
  255. }
  257. if (processingEnvVariable) {
  258. envVariableCount++;
  259. envVar_t envVar;
  260. (*aEnvironmentStructPtr).push_back(envVar);
  261. }
  262. } else if (strcmp(name, "BUFFER") == 0) {
  263. char * bufferName = copy_value(atts[1]);
  264. Buffer* buffer = buffers[bufferName];
  265. if (buffer == NULL) {
  266. currentBufferName = bufferName;
  267. Buffer* buffer = new Buffer();
  268. buffer->name = currentBufferName;
  269. buffer->wireSize = 0;
  270. buffer->memSize = 0;
  271. buffer->lastPad = 0;
  272. buffers[buffer->name] = buffer;
  273. } else {
  274. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml, (char*) "Duplicate buffer detected: " << currentBufferName);
  275. free (bufferName);
  276. currentBufferName = NULL;
  277. }
  278. } else if (strcmp(name, "ATTRIBUTE") == 0) {
  279. if (currentBufferName != NULL) {
  280. Buffer* buffer = buffers[currentBufferName];
  281. Attribute* attribute = new Attribute();
  282. attribute->id = NULL;
  283. attribute->type = NULL;
  284. attribute->count = 0;
  285. attribute->length = 0;
  286. attribute->wirePosition = 0;
  287. attribute->memPosition = 0;
  288. for(int i = 0; atts[i]; i += 2) {
  289. if(strcmp(atts[i], "id") == 0) {
  290. attribute->id = copy_value(atts[i+1]);
  291. } else if(strcmp(atts[i], "type") == 0) {
  292. attribute->type = copy_value(atts[i+1]);
  293. } else if(strcmp(atts[i], "arrayCount") == 0) {
  294. attribute->count = atoi(atts[i+1]);
  295. } else if(strcmp(atts[i], "arrayLength") == 0) {
  296. attribute->length = atoi(atts[i+1]);
  297. }
  298. }
  300. int memTypeSize = -1;
  301. int wireTypeSize = -1;
  302. Attribute* toCheck = buffer->attributes[attribute->id];
  303. bool fail = false;
  304. bool isDbl = false;
  305. if (toCheck == NULL) {
  306. // short, int, long, float, double, char
  307. if (strcmp(attribute->type, "short") == 0) {
  308. memTypeSize = MEM_SHORT_SIZE;
  309. wireTypeSize = WIRE_SHORT_SIZE;
  310. attribute->memSize = memTypeSize;
  311. attribute->wireSize = wireTypeSize;
  312. } else if (strcmp(attribute->type, "int") == 0) {
  313. memTypeSize = MEM_INT_SIZE;
  314. wireTypeSize = WIRE_INT_SIZE;
  315. attribute->memSize = memTypeSize;
  316. attribute->wireSize = wireTypeSize;
  317. } else if (strcmp(attribute->type, "long") == 0) {
  318. memTypeSize = MEM_LONG_SIZE;
  319. wireTypeSize = WIRE_LONG_SIZE;
  320. attribute->memSize = memTypeSize;
  321. attribute->wireSize = wireTypeSize;
  322. } else if (strcmp(attribute->type, "float") == 0) {
  323. memTypeSize = MEM_FLOAT_SIZE;
  324. wireTypeSize = WIRE_FLOAT_SIZE;
  325. attribute->memSize = memTypeSize;
  326. attribute->wireSize = wireTypeSize;
  327. } else if (strcmp(attribute->type, "double") == 0) {
  328. isDbl = true;
  329. memTypeSize = MEM_DOUBLE_SIZE;
  330. wireTypeSize = WIRE_DOUBLE_SIZE;
  331. attribute->memSize = memTypeSize;
  332. attribute->wireSize = wireTypeSize;
  333. } else if (strcmp(attribute->type, "char") == 0) {
  334. memTypeSize = MEM_CHAR_SIZE;
  335. wireTypeSize = WIRE_CHAR_SIZE;
  336. attribute->memSize = memTypeSize;
  337. attribute->wireSize = wireTypeSize;
  338. } else if (strcmp(attribute->type, "char[]") == 0) {
  339. memTypeSize = MEM_CHAR_SIZE;
  340. wireTypeSize = WIRE_CHAR_SIZE;
  341. if (attribute->length == 0) {
  342. attribute->length = 1;
  343. }
  344. attribute->memSize = memTypeSize * attribute->length;
  345. attribute->wireSize = wireTypeSize * attribute->length;
  346. } else if (strcmp(attribute->type, "short[]") == 0) {
  347. memTypeSize = MEM_SHORT_SIZE;
  348. wireTypeSize = WIRE_SHORT_SIZE;
  349. if (attribute->length == 0) {
  350. attribute->length = 1;
  351. }
  352. attribute->memSize = memTypeSize * attribute->length;
  353. attribute->wireSize = wireTypeSize * attribute->length;
  354. } else if (strcmp(attribute->type, "int[]") == 0) {
  355. memTypeSize = MEM_INT_SIZE;
  356. wireTypeSize = WIRE_INT_SIZE;
  357. if (attribute->length == 0) {
  358. attribute->length = 1;
  359. }
  360. attribute->memSize = memTypeSize * attribute->length;
  361. attribute->wireSize = wireTypeSize * attribute->length;
  362. } else if (strcmp(attribute->type, "long[]") == 0) {
  363. memTypeSize = MEM_LONG_SIZE;
  364. wireTypeSize = WIRE_LONG_SIZE;
  365. if (attribute->length == 0) {
  366. attribute->length = 1;
  367. }
  368. attribute->memSize = memTypeSize * attribute->length;
  369. attribute->wireSize = wireTypeSize * attribute->length;
  370. } else if (strcmp(attribute->type, "float[]") == 0) {
  371. memTypeSize = MEM_FLOAT_SIZE;
  372. wireTypeSize = WIRE_FLOAT_SIZE;
  373. if (attribute->length == 0) {
  374. attribute->length = 1;
  375. }
  376. attribute->memSize = memTypeSize * attribute->length;
  377. attribute->wireSize = wireTypeSize * attribute->length;
  378. } else if (strcmp(attribute->type, "double[]") == 0) {
  379. isDbl = true;
  380. memTypeSize = MEM_DOUBLE_SIZE;
  381. wireTypeSize = WIRE_DOUBLE_SIZE;
  382. if (attribute->length == 0) {
  383. attribute->length = 1;
  384. }
  385. attribute->memSize = memTypeSize * attribute->length;
  386. attribute->wireSize = wireTypeSize * attribute->length;
  387. } else if (strcmp(attribute->type, "char[][]") == 0) {
  388. memTypeSize = MEM_CHAR_SIZE;
  389. wireTypeSize = WIRE_CHAR_SIZE;
  390. if (attribute->length == 0) {
  391. attribute->length = 1;
  392. }
  393. if (attribute->count == 0) {
  394. attribute->count = 1;
  395. }
  396. attribute->memSize = memTypeSize * attribute->length * attribute->count;
  397. attribute->wireSize = wireTypeSize * attribute->length * attribute->count;
  398. } else {
  399. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml, (char*) "Unknown attribute type: " << attribute->type);
  400. fail = true;
  401. }
  403. if (!fail) {
  404. buffer->attributes[attribute->id] = attribute;
  406. // doubles are aligned on a (long) word boundary
  407. #ifndef WIN32
  408. if (isDbl) {
  409. memTypeSize = MEM_LONG_SIZE;
  410. }
  411. #endif
  413. // Extend the buffer by the required extra buffer size
  414. if (buffer->lastPad < memTypeSize) {
  415. buffer->lastPad = memTypeSize;
  416. }
  418. // advance to then next alignment boundary
  419. buffer->memSize = buffer->memSize + (buffer->memSize % memTypeSize);
  420. attribute->memPosition = buffer->memSize;
  421. attribute->wirePosition = buffer->wireSize;
  422. buffer->wireSize = buffer->wireSize + attribute->wireSize;
  423. buffer->memSize = buffer->memSize + attribute->memSize;
  424. } else {
  425. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml, (char*) "Cleaning attribute: " << attribute->id);
  426. free(attribute->id);
  427. free(attribute->type);
  428. delete attribute;
  429. }
  430. } else {
  431. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml, (char*) "Duplicate attribute detected: " << attribute->id);
  432. free(attribute->id);
  433. free(attribute->type);
  434. delete attribute;
  435. }
  436. } else {
  437. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml, (char*) "No buffer is being processed");
  438. }
  439. } else if(strcmp(name, "SERVICE") == 0) {
  440. if(atts != 0) {
  441. char  adm[16];
  442. char* server;
  444. server = servers.back()->serverName;
  445. memset(&service, 0, sizeof(ServiceInfo));
  446. ACE_OS::strcpy(adm, "_ADMIN");
  448. service.transportLib = NULL;
  449. service.advertised = false;
  450. service.poolSize = 1;
  452. for(int i = 0; atts[i]; i += 2) {
  453. if(strcmp(atts[i], "name") == 0) {
  454. if(ACE_OS::strstr(atts[i+1], adm)) {
  455. LOG4CXX_WARN(loggerAtmiBrokerEnvXml, (char*) "Can not define " << atts[i+1]);
  456. throw std::exception();
  457. }
  459. if(checkService(server, atts[i+1])) {
  460. LOG4CXX_WARN(loggerAtmiBrokerEnvXml, (char*) "Can not define Same Service " << atts[i+1]);
  461. throw std::exception();
  462. }
  464. service.serviceName = copy_value(atts[i+1]);
  465. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "set name: " << service.serviceName);
  466. } else if(strcmp(atts[i], "function_name") == 0) {
  467. service.function_name = strdup(atts[i+1]);
  468. } else if(strcmp(atts[i], "advertised") == 0) {
  469. if(strcmp(atts[i+1], "true") == 0) {
  470. service.advertised = true;
  471. } else {
  472. service.advertised = false;
  473. }
  474. } else if (strcmp(atts[i], "size") == 0) {
  475. service.poolSize = (short) atol(atts[i+1]);
  476. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "storing size " << service.poolSize);
  477. }
  478. }
  479. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "setting transportlib");
  480. #ifdef WIN32
  481. service.transportLib = strdup("atmibroker-hybrid.dll");
  482. #else
  483. service.transportLib = strdup("libatmibroker-hybrid.so");
  484. #endif
  485. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "set transportlib: " << service.transportLib);
  487. if(service.function_name == NULL) {
  488. service.function_name = copy_value(service.serviceName);
  489. }
  490. }
  491. } else if (strcmp(name, "LIBRARY_NAME") == 0) {
  492. if(atts != 0 && atts[0] && strcmp(atts[0], "configuration") == 0) {
  493. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "comparing" << atts[1] << " with " << configuration);
  494. if (strcmp(atts[1], configuration) == 0) {
  495. service.library_name = copy_value(atts[3]);
  496. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "processed LIBRARY_NAME: " << service.library_name);
  497. } else {
  498. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "CONFIGURATION NOT APPLICABLE FOR LIBRARY_NAME: " << atts[1]);
  499. }
  500. }
  501. }
  502. strcpy(element, name);
  503. strcpy(value, "");
  505. depth += 1;
  506. }
  508. static void XMLCALL endElement
  509. (void *userData, const char *name) {
  510. std::vector<envVar_t>* aEnvironmentStructPtr = (std::vector<envVar_t>*) userData;
  512. bool storedElement = false;
  513. strcpy(last_element, name);
  514. strcpy(last_value, value);
  516. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "storing element: " << last_element);
  518. if (strcmp(last_element, "DOMAIN") == 0) {
  519. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "storing domain value: " << last_value);
  520. storedElement = true;
  521. strcpy(domain, last_value);
  522. } else if (strcmp(last_element, "XA_RESOURCE") == 0) {
  523. processingXaResource = false;
  524. } else if (strcmp(last_element, "XA_RESOURCE_MGR_ID") == 0) {
  525. if (processingXaResource) {
  526. xarmp->resourceMgrId = atol(last_value);
  527. }
  528. } else if (strcmp(last_element, "XA_RESOURCE_NAME") == 0) {
  529. if (processingXaResource) {
  530. xarmp->resourceName = copy_value(last_value);
  531. }
  532. } else if (strcmp(last_element, "XA_OPEN_STRING") == 0) {
  533. if (processingXaResource) {
  534. xarmp->openString = copy_value(last_value);
  535. }
  536. } else if (strcmp(last_element, "XA_CLOSE_STRING") == 0) {
  537. if (processingXaResource) {
  538. xarmp->closeString = copy_value(last_value);
  539. }
  540. } else if (strcmp(last_element, "XA_SWITCH") == 0) {
  541. if (processingXaResource) {
  542. xarmp->xasw = copy_value(last_value);
  543. }
  544. } else if (strcmp(last_element, "XA_LIB_NAME") == 0) {
  545. if (processingXaResource) {
  546. xarmp->xalib = copy_value(last_value);
  547. }
  548. } else if (strcmp(last_element, "ENV_VARIABLE") == 0) {
  549. if (processingEnvVariable) {
  550. int index = envVariableCount - 1;
  551. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "stored EnvVariable at index %d" << index);
  552. }
  553. processingEnvVariable = false;
  554. } else if (strcmp(last_element, "NAME") == 0) {
  555. if (processingEnvVariable) {
  556. int index = envVariableCount - 1;
  557. (*aEnvironmentStructPtr)[index].name = copy_value(last_value);
  558. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "stored EnvName %s at index %d" << last_value << index);
  559. }
  560. } else if (strcmp(last_element, "VALUE") == 0) {
  561. if (processingEnvVariable) {
  562. int index = envVariableCount - 1;
  563. (*aEnvironmentStructPtr)[index].value = copy_value(last_value);
  564. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "stored Env Value %s at index %d" << last_value << index);
  565. }
  566. } else if (strcmp(last_element, "BUFFER") == 0) {
  567. if (currentBufferName != NULL) {
  568. Buffer* buffer = buffers[currentBufferName];
  569. int currentSize = buffer->memSize;
  570. if (currentSize != 0) {
  571. if (currentSize % buffer->lastPad != 0) {
  572. buffer->lastPad = buffer->lastPad - (currentSize % buffer->lastPad);
  573. buffer->memSize = currentSize + buffer->lastPad;
  574. } else {
  575. buffer->lastPad = 0;
  576. }
  577. } else {
  578. buffer->lastPad = 1;
  579. buffer->memSize = 1;
  580. }
  581. currentBufferName = NULL;
  582. }
  583. } else if (strcmp(last_element, "SERVICE") == 0) {
  584. servers.back()->serviceVector.push_back(service);
  585. }
  586. depth -= 1;
  587. }
  589. static void XMLCALL characterData
  590. (void *userData, const char *cdata, int len) {
  591. int i = 0;
  592. int j = 0;
  593. int priorLength = strlen(value);
  595. i = priorLength;
  596. for (; i < len + priorLength; i++, j++) {
  597. value[i] = cdata[j];
  598. }
  599. value[i] = '';
  600. if (value[0] == 'n') {
  601. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "value starts with newline (may be other character data)");
  602. } else {
  603. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "value is :" << value);
  604. }
  605. }
  607. bool AtmiBrokerEnvXml::parseXmlDescriptor(
  608. std::vector<envVar_t>* aEnvironmentStructPtr,
  609. const char * configurationDir, char * conf) {
  611. char aDescriptorFileName[256];
  613. if (configurationDir != NULL) {
  614. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "read env from dir: "
  615. << configurationDir);
  616. ACE_OS::snprintf(aDescriptorFileName, 256, "%s"ACE_DIRECTORY_SEPARATOR_STR_A"btconfig.xml",
  617. configurationDir);
  618. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml,
  619. (char*) "in parseXmlDescriptor() " << aDescriptorFileName);
  620. } else {
  621. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml,
  622. (char*) "read env from default file");
  623. ACE_OS::strcpy(aDescriptorFileName, "btconfig.xml");
  624. }
  625. configuration = conf;
  627. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, "BLACKTIE_CONFIGURATION: " << configuration);
  629. bool toReturn = true;
  630. char schemaPath[256];
  631. char* schemaDir;
  633. schemaDir = ACE_OS::getenv("BLACKTIE_SCHEMA_DIR");
  634. if (schemaDir) {
  635. ACE_OS::snprintf(schemaPath, 256, "%s"ACE_DIRECTORY_SEPARATOR_STR_A"btconfig.xsd", schemaDir);
  636. } else {
  637. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml,
  638. (char*) "BLACKTIE_SCHEMA_DIR is not set, cannot validate configuration");
  639. return false;
  640. }
  642. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "schemaPath is "
  643. << schemaPath);
  645. XsdValidator validator;
  646. if (validator.validate(schemaPath, aDescriptorFileName) == false) {
  647. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml,
  648. (char*) "btconfig.xml did not validate against btconfig.xsd");
  649. return false;
  650. }
  651. struct stat s; /* file stats */
  652. FILE *aDescriptorFile = fopen(aDescriptorFileName, "r");
  654. if (!aDescriptorFile) {
  655. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml,
  656. (char*) "loadfile: fopen failed on %s" << aDescriptorFileName);
  657. return false;
  658. }
  660. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml, (char*) "read file %p"
  661. << aDescriptorFile);
  663. /* Use fstat to obtain the file size */
  664. if (fstat(fileno(aDescriptorFile), &s) != 0) {
  665. /* fstat failed */
  666. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml,
  667. (char*) "loadfile: fstat failed on %s" << aDescriptorFileName);
  668. return false;
  669. }
  670. if (s.st_size == 0) {
  671. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml,
  672. (char*) "loadfile: file %s is empty" << aDescriptorFileName);
  673. }
  674. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml,
  675. (char*) "loadfile: file %s is %d long" << aDescriptorFileName
  676. << s.st_size);
  678. char *buf = (char *) malloc(sizeof(char) * s.st_size + 1);
  679. if (!buf) {
  680. /* malloc failed */
  681. LOG4CXX_ERROR(
  682. loggerAtmiBrokerEnvXml,
  683. (char*) "loadfile: Could not allocate enough memory to load file %s"
  684. << aDescriptorFileName);
  685. return false;
  686. }
  687. memset(buf, '', s.st_size + 1);
  688. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml,
  689. (char*) "loadfile: Allocated enough memory to load file %d"
  690. << s.st_size);
  692. XML_Parser parser = XML_ParserCreate(NULL);
  693. int done;
  694. strcpy(element, "");
  695. strcpy(value, "");
  696. XML_SetUserData(parser, aEnvironmentStructPtr);
  697. XML_SetElementHandler(parser, startElement, endElement);
  698. XML_SetCharacterDataHandler(parser, characterData);
  699. try {
  700. do {
  701. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "reading file");
  702. size_t len = fread(buf, 1, s.st_size, aDescriptorFile);
  703. done = len < sizeof(buf);
  704. if (len > 0) {
  705. LOG4CXX_TRACE(loggerAtmiBrokerEnvXml, (char*) "buf is " << buf);
  707. if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) {
  708. LOG4CXX_ERROR(loggerAtmiBrokerEnvXml, (char*) "%d at line %d"
  709. << XML_ErrorString(XML_GetErrorCode(parser))
  710. << XML_GetCurrentLineNumber(parser));
  711. toReturn = false;
  712. break;
  713. }
  714. }
  715. } while (!done);
  716. } catch (...) {
  717. free(buf);
  718. XML_ParserFree(parser);
  719. fflush(aDescriptorFile);
  720. fclose(aDescriptorFile);
  721. throw;
  722. }
  724. free(buf);
  725. XML_ParserFree(parser);
  727. fflush(aDescriptorFile);
  728. fclose(aDescriptorFile);
  730. LOG4CXX_DEBUG(loggerAtmiBrokerEnvXml,
  731. (char*) "leaving parseXmlDescriptor() %s" << aDescriptorFileName);
  733. if (warnCnt) {
  734. warnCnt = 0;
  735. return false;
  736. }
  738. return toReturn;
  739. }