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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mbus_config.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：24k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mbus_config.c：源码内容
  1. /*
  2.  * FILE:     mbus_config.c
  3.  * AUTHOR:   Colin Perkins
  4.  * MODIFIED: Orion Hodson
  5.  *           Markus Germeier
  6.  * 
  7.  * Copyright (c) 1999-2001 University College London
  8.  * All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, is permitted provided that the following conditions 
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  *      This product includes software developed by the Computer Science
  21.  *      Department at University College London
  22.  * 4. Neither the name of the University nor of the Department may be used
  23.  *    to endorse or promote products derived from this software without
  24.  *    specific prior written permission.
  25.  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  26.  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  29.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35.  * SUCH DAMAGE.
  36.  */
  38. #include "config_unix.h"
  39. #include "config_win32.h"
  40. #include "debug.h"
  41. #include "memory.h"
  42. #include "crypt_random.h"
  43. #include "base64.h"
  44. #include "mbus.h"
  45. #include "mbus_config.h"
  47. #define MBUS_ENCRYPT_BY_DEFAULT
  48. #define MBUS_ENCRKEY_LEN      8
  49. #define MBUS_HASHKEY_LEN     12
  50. #define MBUS_BUF_SIZE    1500
  51. #define MBUS_FILE_NAME   ".mbus"
  52. #define MBUS_FILE_NAME_LEN    5
  54. struct mbus_config {
  55. #ifdef WIN32
  56. HKEY   cfgKey;
  57. #else
  58. fd_t   cfgfd;
  59. #endif
  60. int   cfg_locked;
  61. };
  63. char *mbus_new_encrkey(void)
  64. {
  65. char *key; /* The key we are going to return... */
  66. #ifdef MBUS_ENCRYPT_BY_DEFAULT
  67. /* Create a new key, for use by the hashing routines. Returns */
  68. /* a key of the form (DES,MTIzMTU2MTg5MTEyMQ==)               */
  69. char  random_string[MBUS_ENCRKEY_LEN];
  70. char  encoded_string[(MBUS_ENCRKEY_LEN*4/3)+4];
  71. int  encoded_length;
  72. int  i, j, k;
  74. /* Step 1: generate a random string for the key... */
  75. for (i = 0; i < MBUS_ENCRKEY_LEN; i++) {
  76. random_string[i] = ((int32_t)lbl_random() | 0x000ff000) >> 24;
  77. }
  79. /* Step 2: fill in parity bits to make DES library happy */
  80. for (i = 0; i < MBUS_ENCRKEY_LEN; ++i) {
  81.         k = random_string[i] & 0xfe;
  82. j = k;
  83. j ^= j >> 4;
  84. j ^= j >> 2;
  85. j ^= j >> 1;
  86. j = (j & 1) ^ 1;
  87. random_string[i] = k | j;
  88. }
  90. /* Step 3: base64 encode that string... */
  91. memset(encoded_string, 0, (MBUS_ENCRKEY_LEN*4/3)+4);
  92. encoded_length = base64encode(random_string, MBUS_ENCRKEY_LEN, encoded_string, (MBUS_ENCRKEY_LEN*4/3)+4);
  94. /* Step 4: put it all together to produce the key... */
  95. key = (char *) xmalloc(encoded_length + 18);
  96. sprintf(key, "(DES,%s)", encoded_string);
  97. #else
  98. key = (char *) xmalloc(9);
  99. sprintf(key, "(NOENCR)");
  100. #endif
  101. return key;
  102. }
  104. char *mbus_new_hashkey(void)
  105. {
  106. /* Create a new key, for use by the hashing routines. Returns  */
  107. /* a key of the form (HMAC-MD5-96,MTIzMTU2MTg5MTEyMQ==)           */
  108. char  random_string[MBUS_HASHKEY_LEN];
  109. char  encoded_string[(MBUS_HASHKEY_LEN*4/3)+4];
  110. int  encoded_length;
  111. int  i;
  112. char *key;
  114. /* Step 1: generate a random string for the key... */
  115. for (i = 0; i < MBUS_HASHKEY_LEN; i++) {
  116. random_string[i] = ((int32_t)lbl_random() | 0x000ff000) >> 24;
  117. }
  118. /* Step 2: base64 encode that string... */
  119. memset(encoded_string, 0, (MBUS_HASHKEY_LEN*4/3)+4);
  120. encoded_length = base64encode(random_string, MBUS_HASHKEY_LEN, encoded_string, (MBUS_HASHKEY_LEN*4/3)+4);
  122. /* Step 3: put it all together to produce the key... */
  123. key = (char *) xmalloc(encoded_length + 26);
  124. sprintf(key, "(HMAC-MD5-96,%s)", encoded_string);
  126. return key;
  127. }
  129. static void rewrite_config(struct mbus_config *m)
  130. {
  131. #ifdef WIN32
  132. char *hashkey = mbus_new_hashkey();
  133. char *encrkey = mbus_new_encrkey();
  134. char *scope   = MBUS_DEFAULT_SCOPE_NAME;
  135. const uint32_t  cver    = MBUS_CONFIG_VERSION;
  136. const uint32_t  port    = MBUS_DEFAULT_NET_PORT;
  137. char *addr    = xstrdup(MBUS_DEFAULT_NET_ADDR);
  138. char  buffer[MBUS_BUF_SIZE];
  139. LONG  status;
  141. status = RegSetValueEx(m->cfgKey, "CONFIG_VERSION", 0, REG_DWORD, (const uint8_t *) &cver, sizeof(cver));
  142. if (status != ERROR_SUCCESS) {
  143. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  144. debug_msg("Unable to set version: %sn", buffer);
  145. abort();
  146. }
  147. status = RegSetValueEx(m->cfgKey, "HASHKEY", 0, REG_SZ, hashkey, strlen(hashkey) + 1);
  148. if (status != ERROR_SUCCESS) {
  149. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  150. debug_msg("Unable to set hashkey: %sn", buffer);
  151. abort();
  152. }
  153. status = RegSetValueEx(m->cfgKey, "ENCRYPTIONKEY", 0, REG_SZ, encrkey, strlen(encrkey) + 1);
  154. if (status != ERROR_SUCCESS) {
  155. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  156. debug_msg("Unable to set encrkey: %sn", buffer);
  157. abort();
  158. }
  159. status = RegSetValueEx(m->cfgKey, "SCOPE", 0, REG_SZ, scope, strlen(scope) + 1);
  160. if (status != ERROR_SUCCESS) {
  161. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  162. debug_msg("Unable to set scope: %sn", buffer);
  163. abort();
  164. }
  165. status = RegSetValueEx(m->cfgKey, "ADDRESS", 0, REG_SZ, addr, strlen(addr) + 1);
  166. if (status != ERROR_SUCCESS) {
  167. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  168. debug_msg("Unable to set address: %sn", buffer);
  169. abort();
  170. }
  171. status = RegSetValueEx(m->cfgKey, "PORT", 0, REG_DWORD, (const uint8_t *) &port, sizeof(port));
  172. if (status != ERROR_SUCCESS) {
  173. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  174. debug_msg("Unable to set port: %sn", buffer);
  175. abort();
  176. }
  177. xfree(addr);
  178. #else
  179. char *hashkey = mbus_new_hashkey();
  180. char *encrkey = mbus_new_encrkey();
  181. char  buf[1024];
  183. if (lseek(m->cfgfd, 0, SEEK_SET) == -1) {
  184. perror("Can't seek to start of config file");
  185. abort();
  186. }
  187. sprintf(buf, "[MBUS]nCONFIG_VERSION=%dnHASHKEY=%snENCRYPTIONKEY=%snSCOPE=%snADDRESS=%snPORT=%dn", 
  188. MBUS_CONFIG_VERSION, hashkey, encrkey, MBUS_DEFAULT_SCOPE_NAME, MBUS_DEFAULT_NET_ADDR, MBUS_DEFAULT_NET_PORT);
  189. write(m->cfgfd, buf, strlen(buf));
  190. free(hashkey);
  191. xfree(encrkey);
  192. #endif
  193. }
  195. void mbus_lock_config_file(struct mbus_config *m)
  196. {
  197. #ifdef WIN32
  198. /* Open the registry and create the mbus entries if they don't exist   */
  199. /* already. The default contents of the registry are random encryption */
  200. /* and authentication keys, and node local scope.                      */
  201. HKEY key    = HKEY_CURRENT_USER;
  202. LPCTSTR subKey = "Software\Mbone Applications\mbus";
  203. DWORD disp;
  204. char buffer[MBUS_BUF_SIZE];
  205. LONG status;
  207. status = RegCreateKeyEx(key, subKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &(m->cfgKey), &disp);
  208. if (status != ERROR_SUCCESS) {
  209. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  210. debug_msg("Unable to open registry: %sn", buffer);
  211. abort();
  212. }
  213. if (disp == REG_CREATED_NEW_KEY) {
  214. rewrite_config(m);
  215. debug_msg("Created new registry entry...n");
  216. } else {
  217. debug_msg("Opened existing registry entry...n");
  218. }
  219. #else
  220. /* Obtain a valid lock on the mbus configuration file. This function */
  221. /* creates the file, if one does not exist. The default contents of  */
  222. /* this file are random authentication and encryption keys, and node */
  223. /* local scope.                                                      */
  224. struct flock  l;
  225. struct stat  s;
  226. char *buf;
  227. char *cfg_file;
  228. char            *cfg_loc;
  229. int              cfg_loc_len;
  231. cfg_loc = getenv("MBUS");
  232. if (cfg_loc == NULL) {
  233.                 cfg_loc = getenv("HOME");
  234.                 if (cfg_loc == NULL) {
  235.                         /* The getpwuid() stuff is to determine the users    */
  236.                         /* home directory, into which we write a .mbus       */
  237.                         /* config file. The struct returned by getpwuid() is */
  238.                         /* statically allocated, so it's not necessary to    */
  239.                         /* free it afterwards.                               */
  240.                         struct passwd *p;
  241.                         p = getpwuid(getuid());
  242.                         if (p == NULL) {
  243.                                 perror("Unable to get passwd entry");
  244.                                 abort();       
  245.                         }
  246.                         cfg_loc = p->pw_dir;
  247.                 }
  248. }
  250. /* Check if config_loc is terminated by mbus config file name. If    */
  251.         /* it's not add it.  This is allows environment variable MBUS to     */
  252.         /* point to config file of directory of config file.                 */
  253.         cfg_loc_len = strlen(cfg_loc);
  254. if (cfg_loc_len < MBUS_FILE_NAME_LEN ||
  255.     strcmp(cfg_loc + cfg_loc_len - MBUS_FILE_NAME_LEN, MBUS_FILE_NAME)){
  256.                 /* File location does not include config file name.          */
  257.                 cfg_file = (char*)xmalloc(cfg_loc_len + MBUS_FILE_NAME_LEN + 2);
  258.                 sprintf(cfg_file, "%s/%s", cfg_loc, MBUS_FILE_NAME);
  259. } else {
  260.                 cfg_file = xstrdup(cfg_loc);
  261. }
  262.         
  263. m->cfgfd = open(cfg_file, O_RDWR | O_CREAT, 0600);
  264. if (m->cfgfd == -1) {
  265. perror("Unable to open mbus configuration file");
  266. abort();
  267. }
  269. /* We attempt to get a lock on the config file, blocking until  */
  270. /* the lock can be obtained. The only time this should block is */
  271. /* when another instance of this code has a write lock on the   */
  272. /* file, because the contents are being updated.                */
  273. l.l_type   = F_WRLCK;
  274. l.l_start  = 0;
  275. l.l_whence = SEEK_SET;
  276. l.l_len    = 0;
  277. if (fcntl(m->cfgfd, F_SETLKW, &l) == -1) {
  278. perror("Unable to lock mbus configuration file");
  279. printf("The most likely reason for this error is that %sn", cfg_file);
  280. printf("is on an NFS filestore, and you have not correctly setup file locking. n");
  281. printf("Ask your system administrator to ensure that rpc.lockd and/or rpc.statdn");
  282. printf("are running. n");
  283. abort();
  284. }
  286. xfree(cfg_file);
  288. if (fstat(m->cfgfd, &s) != 0) {
  289. perror("Unable to stat config filen");
  290. abort();
  291. }
  292. if (s.st_size == 0) {
  293. /* Empty file, create with sensible defaults... */
  294. rewrite_config(m);
  295. } else {
  296. /* Read in the contents of the config file... */
  297. buf = (char *) xmalloc(s.st_size+1);
  298. memset(buf, '', s.st_size+1);
  299. if (read(m->cfgfd, buf, s.st_size) != s.st_size) {
  300. perror("Unable to read config filen");
  301. abort();
  302. }
  303. /* Check that the file contains sensible information...   */
  304. /* This is rather a pathetic check, but it'll do for now! */
  305. if (strncmp(buf, "[MBUS]", 6) != 0) {
  306. debug_msg("Mbus config file has incorrect headern");
  307. abort();
  308. }
  309. xfree(buf);
  310. }
  311. #endif
  312. m->cfg_locked = TRUE;
  313. if (mbus_get_version(m) < MBUS_CONFIG_VERSION) {
  314. rewrite_config(m);
  315. debug_msg("Updated Mbus configuration database.n");
  316. }
  317. if (mbus_get_version(m) > MBUS_CONFIG_VERSION) {
  318. debug_msg("Mbus configuration database has later version number than expected.n");
  319. debug_msg("Continuing, in the hope that the extensions are backwards compatible.n");
  320. }
  321. }
  323. void mbus_unlock_config_file(struct mbus_config *m)
  324. {
  325. #ifdef WIN32
  326. LONG status;
  327. char buffer[MBUS_BUF_SIZE];
  329. status = RegCloseKey(m->cfgKey);
  330. if (status != ERROR_SUCCESS) {
  331. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  332. debug_msg("Unable to close registry: %sn", buffer);
  333. abort();
  334. }
  335. debug_msg("Closed registry entry...n");
  336. #else
  337. struct flock l;
  339. l.l_type   = F_UNLCK;
  340. l.l_start  = 0;
  341. l.l_whence = SEEK_SET;
  342. l.l_len    = 0;
  343. if (fcntl(m->cfgfd, F_SETLKW, &l) == -1) {
  344. perror("Unable to unlock mbus configuration file");
  345. abort();
  346. }
  347. close(m->cfgfd);
  348. m->cfgfd = -1;
  349. #endif
  350. m->cfg_locked = FALSE;
  351. }
  353. #ifndef WIN32
  354. static void mbus_get_key(struct mbus_config *m, struct mbus_key *key, const char *id)
  355. {
  356. struct stat  s;
  357. char *buf;
  358. char *line;
  359. char *tmp;
  360. int  pos;
  361.         int              linepos;
  363. ASSERT(m->cfg_locked);
  365. if (lseek(m->cfgfd, 0, SEEK_SET) == -1) {
  366. perror("Can't seek to start of config file");
  367. abort();
  368. }
  369. if (fstat(m->cfgfd, &s) != 0) {
  370. perror("Unable to stat config filen");
  371. abort();
  372. }
  373. /* Read in the contents of the config file... */
  374. buf = (char *) xmalloc(s.st_size+1);
  375. memset(buf, '', s.st_size+1);
  376. if (read(m->cfgfd, buf, s.st_size) != s.st_size) {
  377. perror("Unable to read config filen");
  378. abort();
  379. }
  381. line = (char *) xmalloc(s.st_size+1);
  382. sscanf(buf, "%s", line);
  383. if (strcmp(line, "[MBUS]") != 0) {
  384. debug_msg("Invalid .mbus filen");
  385. abort();
  386. }
  387. pos = strlen(line) + 1;
  388. while (pos < s.st_size) {
  389.                 /* get whole line and filter out spaces */
  390.                 /* this is good enough for getting keys */
  391.                 linepos=0;
  392.                 do {
  393.                     while((buf[pos+linepos]==' ')||(buf[pos+linepos]=='n')
  394.                                                  ||(buf[pos+linepos]=='t'))
  395.                         pos++;
  396.                     sscanf(buf+pos+linepos, "%s", line+linepos);                
  397.                     linepos = strlen(line);
  398.                 } while((buf[pos+linepos]!='n') && (s.st_size>(pos+linepos+1)));
  399.                 pos += linepos + 1;
  400. if (strncmp(line, id, strlen(id)) == 0) {
  401. key->algorithm   = (char *) strdup(strtok(line+strlen(id), ",)"));
  402. if (strcmp(key->algorithm, "NOENCR") != 0) {
  403. key->key     = (char *) strtok(NULL  , ")");
  404.                                 ASSERT(key->key!=NULL);
  405. key->key_len = strlen(key->key);
  406. tmp = (char *) xmalloc(key->key_len);
  407. key->key_len = base64decode(key->key, key->key_len, tmp, key->key_len);
  408. key->key = tmp;
  409. } else {
  410. key->key     = NULL;
  411. key->key_len = 0;
  412. }
  413. xfree(buf);
  414. xfree(line);
  415. return;
  416. }
  417. }
  418. debug_msg("Unable to read hashkey from config filen");
  419. xfree(buf);
  420. xfree(line);
  421. }
  422. #endif
  424. void mbus_get_encrkey(struct mbus_config *m, struct mbus_key *key)
  425. {
  426. /* This MUST be called while the config file is locked! */
  427. int  i, j, k;
  428. #ifdef WIN32
  429. long  status;
  430. DWORD  type;
  431. char *buffer;
  432. int    buflen = MBUS_BUF_SIZE;
  433. char *tmp;
  435. ASSERT(m->cfg_locked);
  437. /* Read the key from the registry... */
  438. buffer = (char *) xmalloc(MBUS_BUF_SIZE);
  439. status = RegQueryValueEx(m->cfgKey, "ENCRYPTIONKEY", 0, &type, buffer, &buflen);
  440. if (status != ERROR_SUCCESS) {
  441. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  442. debug_msg("Unable to get encrkey: %sn", buffer);
  443. abort();
  444. }
  445. ASSERT(type == REG_SZ);
  446. ASSERT(buflen > 0);
  448. /* Parse the key... */
  449. key->algorithm   = strdup(strtok(buffer+1, ",)"));
  450. if (strcmp(key->algorithm, "NOENCR") != 0) {
  451. key->key     = (char *) strtok(NULL  , ")");
  452. key->key_len = strlen(key->key);
  453. tmp = (char *) xmalloc(key->key_len);
  454. key->key_len = base64decode(key->key, key->key_len, tmp, key->key_len);
  455. key->key = tmp;
  456. } else {
  457. key->key     = NULL;
  458. key->key_len = 0;
  459. }
  460. xfree(buffer);
  461. #else
  462. mbus_get_key(m, key, "ENCRYPTIONKEY=(");
  463. #endif
  464. if (strcmp(key->algorithm, "DES") == 0) {
  465. ASSERT(key->key != NULL);
  466. ASSERT(key->key_len == 8);
  468. /* check parity bits */
  469. for (i = 0; i < 8; ++i) 
  470. {
  471. k = key->key[i] & 0xfe;
  472. j = k;
  473. j ^= j >> 4;
  474. j ^= j >> 2;
  475. j ^= j >> 1;
  476. j = (j & 1) ^ 1;
  477. ASSERT((key->key[i] & 0x01) == j);
  478. }
  479. }
  480. }
  482. void mbus_get_hashkey(struct mbus_config *m, struct mbus_key *key)
  483. {
  484. /* This MUST be called while the config file is locked! */
  485. #ifdef WIN32
  486. long  status;
  487. DWORD  type;
  488. char *buffer;
  489. int  buflen = MBUS_BUF_SIZE;
  490. char *tmp;
  492. ASSERT(m->cfg_locked);
  494. /* Read the key from the registry... */
  495. buffer = (char *) xmalloc(MBUS_BUF_SIZE);
  496. status = RegQueryValueEx(m->cfgKey, "HASHKEY", 0, &type, buffer, &buflen);
  497. if (status != ERROR_SUCCESS) {
  498. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  499. debug_msg("Unable to get encrkey: %sn", buffer);
  500. abort();
  501. }
  502. ASSERT(type == REG_SZ);
  503. ASSERT(buflen > 0);
  505. /* Parse the key... */
  506. key->algorithm   = strdup(strtok(buffer+1, ","));
  507. key->key         = strtok(NULL  , ")");
  508. key->key_len     = strlen(key->key);
  510. /* Decode the key... */
  511. tmp = (char *) xmalloc(key->key_len);
  512. key->key_len = base64decode(key->key, key->key_len, tmp, key->key_len);
  513. key->key = tmp;
  515. xfree(buffer);
  516. #else
  517. mbus_get_key(m, key, "HASHKEY=(");
  518. #endif
  519. }
  521. void mbus_get_net_addr(struct mbus_config *m, char *net_addr, uint16_t *net_port, int *net_scope)
  522. {
  523. #ifdef WIN32
  524. long  status;
  525. DWORD  type;
  526. char *buffer;
  527. int  buflen = MBUS_BUF_SIZE;
  528. uint32_t port;
  530. ASSERT(m->cfg_locked);
  532. /* Read the key from the registry... */
  533. buffer = (char *) xmalloc(MBUS_BUF_SIZE);
  534.         buflen = MBUS_BUF_SIZE;
  535. status = RegQueryValueEx(m->cfgKey, "ADDRESS", 0, &type, buffer, &buflen);
  536. if (status != ERROR_SUCCESS) {
  537. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  538. debug_msg("Unable to get address: %sn", buffer);
  539. strcpy(net_addr, MBUS_DEFAULT_NET_ADDR);
  540. } else {
  541. ASSERT(type == REG_SZ);
  542. ASSERT(buflen > 0);
  543. strncpy(net_addr, buffer, buflen);
  544. }
  546. buflen = sizeof(port);
  547. status = RegQueryValueEx(m->cfgKey, "PORT", 0, &type, (uint8_t *) &port, &buflen);
  548. if (status != ERROR_SUCCESS) {
  549. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  550. debug_msg("Unable to get port: %sn", buffer);
  551. *net_port  = MBUS_DEFAULT_NET_PORT;
  552. } else {
  553. ASSERT(type == REG_DWORD);
  554. ASSERT(buflen == 4);
  555. *net_port = (uint16_t) port;
  556. }
  558. buflen = MBUS_BUF_SIZE;
  559. status = RegQueryValueEx(m->cfgKey, "SCOPE", 0, &type, buffer, &buflen);
  560. if (status != ERROR_SUCCESS) {
  561. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  562. debug_msg("Unable to get scope: %sn", buffer);
  563. *net_scope = MBUS_DEFAULT_SCOPE;
  564. } else {
  565. ASSERT(type == REG_SZ);
  566. ASSERT(buflen > 0);
  567. if (strncmp(buffer, SCOPE_HOSTLOCAL_NAME, strlen(SCOPE_HOSTLOCAL_NAME)) == 0) {
  568. *net_scope = SCOPE_HOSTLOCAL;
  569. } else if (strncmp(buffer, SCOPE_LINKLOCAL_NAME, strlen(SCOPE_LINKLOCAL_NAME)) == 0) {
  570. *net_scope = SCOPE_LINKLOCAL;
  571. } else {
  572. debug_msg("Unrecognized scope: %sn", buffer);
  573. *net_scope = MBUS_DEFAULT_SCOPE;
  574. }
  575. }
  576.         xfree(buffer);
  577. #else
  578. struct stat  s;
  579. char *buf;
  580. char *line;
  581. int  pos;
  582. int              pos2;
  583.         int              linepos;
  585. int              scope;
  586. char            *addr;
  587. uint16_t        port;
  589. ASSERT(m->cfg_locked);
  591. addr = (char *)xmalloc(20);
  592. memset(addr, 0, 20);
  593. port = 0;
  594. scope = -1;
  597. if (lseek(m->cfgfd, 0, SEEK_SET) == -1) {
  598. perror("Can't seek to start of config file");
  599. abort();
  600. }
  601. if (fstat(m->cfgfd, &s) != 0) {
  602. perror("Unable to stat config filen");
  603. abort();
  604. }
  605. /* Read in the contents of the config file... */
  606. buf = (char *) xmalloc(s.st_size+1);
  607. memset(buf, '', s.st_size+1);
  608. if (read(m->cfgfd, buf, s.st_size) != s.st_size) {
  609. perror("Unable to read config filen");
  610. abort();
  611. }
  613. line = (char *) xmalloc(s.st_size+1);
  614. sscanf(buf, "%s", line);
  615. if (strcmp(line, "[MBUS]") != 0) {
  616. debug_msg("Invalid .mbus filen");
  617. abort();
  618. }
  619. pos = strlen(line) + 1;
  620. while (pos < s.st_size) {
  621.                 /* get whole line and filter out spaces */
  622.                 linepos=0;
  623.                 do {
  624.                     while((buf[pos+linepos]==' ')||(buf[pos+linepos]=='n')
  625.                                                  ||(buf[pos+linepos]=='t'))
  626.                         pos++;
  627.                     sscanf(buf+pos+linepos, "%s", line+linepos);                
  628.                     linepos = strlen(line);
  629.   
  630.                 } while((buf[pos+linepos]!='n') && (s.st_size>(pos+linepos+1)));
  631.                 pos += linepos + 1;     
  632. if (strncmp(line, "SCOPE", strlen("SCOPE")) == 0) {
  633.     pos2 = strlen("SCOPE") + 1;
  634.     if (strncmp(line+pos2, SCOPE_HOSTLOCAL_NAME, 
  635. strlen(SCOPE_HOSTLOCAL_NAME)) == 0) {
  636. scope = SCOPE_HOSTLOCAL;
  637.     }
  638.     if (strncmp(line+pos2, SCOPE_LINKLOCAL_NAME, 
  639. strlen(SCOPE_LINKLOCAL_NAME)) == 0) {
  640. scope = SCOPE_LINKLOCAL ;
  641.     }
  642. }
  643. if (strncmp(line, "ADDRESS", strlen("ADDRESS")) == 0) {
  644.     pos2 = strlen("ADDRESS") + 1;
  645.     strncpy(addr, line+pos2, 16);
  646. }
  647. if (strncmp(line, "PORT", strlen("PORT")) == 0) {
  648.     pos2 = strlen("PORT") + 1;
  649.     port = atoi(line+pos2);
  650. }
  651.     
  652. }
  653. /* If we did not find all values, fill in the default ones */
  654. *net_port  = (port>0)?port:MBUS_DEFAULT_NET_PORT;
  655. *net_scope = (scope!=-1)?scope:MBUS_DEFAULT_SCOPE;
  656. if (strlen(addr)>0) {
  657. strncpy(net_addr, addr, 16);
  658. } else {
  659. strcpy(net_addr, MBUS_DEFAULT_NET_ADDR);
  660. }
  661. debug_msg("using Addr:%s Port:%d Scope:%s for MBUSn", 
  662.   net_addr, *net_port, (*net_scope==0)?SCOPE_HOSTLOCAL_NAME:SCOPE_LINKLOCAL_NAME);
  663. xfree(buf);
  664. xfree(line);
  665. xfree(addr);
  666. #endif
  667. }
  669. int mbus_get_version(struct mbus_config *m)
  670. {
  671. #ifdef WIN32
  672. long status;
  673. DWORD type;
  674. uint32_t cver;
  675. int verl;
  676. char buffer[MBUS_BUF_SIZE];
  678. ASSERT(m->cfg_locked);
  680. /* Read the key from the registry... */
  681.         verl = sizeof(&cver);
  682. status = RegQueryValueEx(m->cfgKey, "CONFIG_VERSION", 0, &type, (uint8_t *) &cver, &verl);
  683. if (status != ERROR_SUCCESS) {
  684. FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, status, 0, buffer, MBUS_BUF_SIZE, NULL);
  685. debug_msg("Unable to get version: %sn", buffer);
  686. return 0;
  687. }
  688. ASSERT(type == REG_DWORD);
  689. ASSERT(verl == 4);
  690. return cver;
  691. #else
  692. struct stat  s;
  693. char *buf;
  694. char *line;
  695. int  pos;
  696. int              pos2;
  697.         int              linepos;
  698. int  version = 0;
  700. ASSERT(m->cfg_locked);
  702. if (lseek(m->cfgfd, 0, SEEK_SET) == -1) {
  703. perror("Can't seek to start of config file");
  704. abort();
  705. }
  706. if (fstat(m->cfgfd, &s) != 0) {
  707. perror("Unable to stat config filen");
  708. abort();
  709. }
  710. /* Read in the contents of the config file... */
  711. buf = (char *) xmalloc(s.st_size+1);
  712. memset(buf, '', s.st_size+1);
  713. if (read(m->cfgfd, buf, s.st_size) != s.st_size) {
  714. perror("Unable to read config filen");
  715. abort();
  716. }
  718. line = (char *) xmalloc(s.st_size+1);
  719. sscanf(buf, "%s", line);
  720. if (strcmp(line, "[MBUS]") != 0) {
  721. debug_msg("Invalid .mbus filen");
  722. abort();
  723. }
  724. pos = strlen(line) + 1;
  725. while (pos < s.st_size) {
  726.                 /* get whole line and filter out spaces */
  727.                 linepos=0;
  728.                 do {
  729. while((buf[pos+linepos]==' ')||(buf[pos+linepos]=='n') ||(buf[pos+linepos]=='t')) {
  730. pos++;
  731. }
  732. sscanf(buf+pos+linepos, "%s", line+linepos);                
  733. linepos = strlen(line);
  734.                 } while((buf[pos+linepos]!='n') && (s.st_size>(pos+linepos+1)));
  735.                 pos += linepos + 1;     
  736. if (strncmp(line, "CONFIG_VERSION", strlen("CONFIG_VERSION")) == 0) {
  737.     pos2    = strlen("CONFIG_VERSION") + 1;
  738.     version = atoi(line+pos2);
  739. }
  740.     
  741. }
  742. xfree(buf);
  743. xfree(line);
  744. return version;
  745. #endif
  746. }
  748. struct mbus_config *mbus_create_config(void)
  749. {
  750. return (struct mbus_config *) xmalloc(sizeof(struct mbus_config));
  751. }