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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机短信编程 > 查看源码
parserc.c
资源名称：sms_client-2.0.7k.tgz　[点击查看]
上传用户：mei_mei897
上传日期：2007-01-05
资源大小：82k
文件大小：16k
源码类别：

手机短信编程

开发平台：

Unix_Linux

parserc.c：源码内容
  1. /* -------------------------------------------------------------------- */
  2. /* SMS Client, send messages to mobile phones and pagers */
  3. /* */
  4. /* parserc.c */
  5. /* */
  6. /*  Copyright (C) 1997,1998 Angelo Masci */
  7. /* */
  8. /*  This library is free software; you can redistribute it and/or */
  9. /*  modify it under the terms of the GNU Library General Public */
  10. /*  License as published by the Free Software Foundation; either */
  11. /*  version 2 of the License, or (at your option) any later version. */
  12. /* */
  13. /*  This library is distributed in the hope that it will be useful, */
  14. /*  but WITHOUT ANY WARRANTY; without even the implied warranty of */
  15. /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
  16. /*  Library General Public License for more details. */
  17. /* */
  18. /*  You should have received a copy of the GNU Library General Public */
  19. /*  License along with this library; if not, write to the Free */
  20. /*  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  21. /* */
  22. /*  You can contact the author at this e-mail address: */
  23. /* */
  24. /*  angelo@styx.demon.co.uk */
  25. /* */
  26. /* -------------------------------------------------------------------- */
  27. /* $Id: parserc.c,v 5.1 1998/02/01 07:10:39 root Exp root $
  28.    -------------------------------------------------------------------- */
  30. #include <stdio.h>
  31. #include <ctype.h>
  32. #include <string.h>
  33. #include <stdlib.h>
  34. #include <limits.h>
  35. #include <sys/types.h>
  36. #include <pwd.h>
  37. #include <unistd.h>
  38. #include <stddef.h>
  40. #if defined(NEXT)
  41. #include <sys/dir.h>
  42. #include <sys/dirent.h>
  43. #define NAME_MAX 255
  44. #define PATH_MAX 1024
  45. #else
  46. #include <dirent.h>
  47. #endif
  49. #include "sms_error.h"
  50. #include "logfile.h"
  51. #include "parserc.h"
  52. #include "sms_list.h"
  53. #include "sms_resource.h"
  54. #include "driver/driver.h"
  56. #include "token.h"
  57. #include "common.h"
  59. /* -------------------------------------------------------------------- */
  60. /* -------------------------------------------------------------------- */
  62. #define MAXRCLINELEN  80
  63. #define DELIMETER  '='
  66. #if !defined(MLOCALSMSRC)
  67. #error "MLOCALSMSRC undefined"
  68. #else
  69. #define LOCALSMSRC      MLOCALSMSRC
  70. #endif
  72. #if !defined(MGLOBALSMSRC)
  73. #error "MGLOBALSMSRC undefined"
  74. #else
  75. #define GLOBALSMSRC     MGLOBALSMSRC
  76. #endif
  78. #if !defined(MSERVICEDIR)
  79. #error "MSERVICEDIR undefined"
  80. #else
  81. #define SERVICEDIR      MSERVICEDIR
  82. #endif
  84. /* -------------------------------------------------------------------- */
  86. static  RESOURCE
  87. *SMS_services_list = NULL;
  89. SMS_list *search_list;
  91. /* -------------------------------------------------------------------- */
  93. static FILE *SMS_open_global_smsrc(void);
  94. static FILE *SMS_open_local_smsrc(void);
  95. static void SMS_close_smsrc(FILE *fp);
  96. static void read_services(void);
  98. static SMS_list *expandnumber(FILE *fp[2], char *id, char *str, char *default_service);
  100. /* -------------------------------------------------------------------- */
  101. /* -------------------------------------------------------------------- */
  102. static FILE *SMS_open_global_smsrc(void)
  103. {
  104. lprintf(LOG_VERBOSE, "Opening Global Addressbook File: %sn", GLOBALSMSRC);
  106. return fopen(GLOBALSMSRC, "r");
  107. }
  110. /* -------------------------------------------------------------------- */
  111. /* -------------------------------------------------------------------- */
  112. #if defined(SOLARIS)
  113. #define NAME_MAX FILENAME_MAX
  114. #endif
  116. #if defined(AIX)
  117. #define NAME_MAX 512
  118. #endif
  120. static FILE *SMS_open_local_smsrc(void)
  121. {
  122. struct passwd
  123. *pentry;
  125. char  filename[PATH_MAX + NAME_MAX +1];
  128. pentry = getpwuid(getuid());
  130. sms_strcpy(filename, pentry->pw_dir);
  131. sms_strcat(filename, "/");
  132. sms_strcat(filename, LOCALSMSRC);
  134. lprintf(LOG_VERBOSE, "Opening Local Addressbook File: %sn", filename);
  136. return fopen(filename, "r");
  137. }
  140. /* -------------------------------------------------------------------- */
  141. /* -------------------------------------------------------------------- */
  142. static void SMS_close_smsrc(FILE *fp)
  143. {
  144. if (fp != NULL)
  145. { fclose(fp);
  146. }
  147. }
  150. /* -------------------------------------------------------------------- */
  151. /* -------------------------------------------------------------------- */
  152. int is_name(char *name)
  153. {
  154. char  *ptr;
  157. ptr = name;
  158. if (isdigit(*ptr)) /* First character NUMERIC  */
  159. { /* This is NOT a NAME */
  160. return FALSE;
  161. }
  163. while (*ptr != '')
  164. {
  165. if (*ptr == ':') /* Contains ':' this */
  166. { /* this is NOT a NAME */
  167. /* */
  168. /* SERVICE:NUMBER */
  170. return FALSE;
  171. }
  173. ptr++;
  174. }
  176. return TRUE;
  177. }
  182. /* -------------------------------------------------------------------- */
  183. /* -------------------------------------------------------------------- */
  184. char *SMS_get_smsrc_value(FILE *fp, char *name)
  185. {
  186. char  line[MAXRCLINELEN],
  187. SMS_name[MAXRCLINELEN],
  188. token[MAXRCLINELEN],
  189.   *SMS_value,
  190.   *src;
  192. int type,
  193. line_count;
  196. if (fp == NULL)
  197. { return NULL;
  198. }
  200. rewind(fp);
  203. SMS_value = (char *)malloc(sizeof(char) * MAXRCLINELEN);
  204. if (SMS_value == NULL)
  205. {
  206. lprintf(LOG_ERROR, "Allocating memoryn");
  207. exit(EMALLOC);
  208. }
  211. line_count = 0;
  212. while (get_line(line, MAXRCLINELEN, &line_count, fp) != NULL)
  213. {
  214. src = line;
  216. type = get_token(SMS_name, MAXRCLINELEN, src, &src);
  217. if (type != STRING_TOKEN)
  218. {
  219. if (type == COMMENT_TOKEN)
  220. { continue;
  221. }
  223. lprintf(LOG_VERBOSE, "Syntax Error: Name expected at line %dn", line_count);
  224. return NULL;
  225. }
  227. type = get_token(token, MAXRCLINELEN, src, &src);
  228. if (type != ASSIGNMENT_TOKEN)
  229. {
  230. lprintf(LOG_VERBOSE, "Syntax Error: Assignment expected at line %dn", line_count);
  231. return NULL;
  232. }
  234. type = get_token(SMS_value, MAXRCLINELEN, src, &src);
  235. if ((type != STRING_TOKEN) &&
  236.     (type != QUOTED_STRING_TOKEN) &&
  237.     (type != SINGLE_QUOTED_STRING_TOKEN) &&
  238.     (type != NULL_TOKEN))
  239. {
  240. lprintf(LOG_VERBOSE, "Syntax Error: String expected at line %dn", line_count);
  241. return NULL;
  242. }
  244. type = get_token(token, MAXRCLINELEN, src, &src);
  245. if ((type != NULL_TOKEN) &&
  246.     (type != COMMENT_TOKEN))
  247. {
  248. lprintf(LOG_VERBOSE, "Syntax Error: EOL or comment expected at line %dn", line_count);
  249. return NULL;
  250. }
  252. if (strcmp(name, SMS_name) == 0)
  253. {
  254. lprintf(LOG_VERBOSE, "Name Found: %s = %sn", SMS_name, SMS_value);
  255. return SMS_value;
  256. } 
  257. }
  259. lprintf(LOG_VERBOSE, "Name NOT Found: %sn", name);
  261. free(SMS_value);
  262. return NULL;
  263. }
  266. /* -------------------------------------------------------------------- */
  267. /* -------------------------------------------------------------------- */
  268. char *SMS_dual_get_smsrc_value(FILE **fp, char *name)
  269. {
  270. char  *ptr;
  273. ptr = SMS_get_smsrc_value(fp[0], name);
  274. if (ptr != NULL)
  275. { return ptr;
  276. }
  278. ptr = SMS_get_smsrc_value(fp[1], name);
  279. if (ptr != NULL)
  280. { return ptr;
  281. }
  283. return NULL;
  284. }
  287. /* -------------------------------------------------------------------- */
  288. /* -------------------------------------------------------------------- */
  289. int SMS_getnamevalue_numeric(FILE *fp, char *name, long *value)
  290. {
  291. char  *str,
  292. *ptr;
  294. str = SMS_get_smsrc_value(fp, name);
  295. if (str == NULL)
  296. { return -1;
  297. }
  299. *value = strtol(str, &ptr, 10);
  301. if (ptr == str)
  302. { return -1;
  303. }
  305. return 0;
  306. }
  309. /* -------------------------------------------------------------------- */
  310. /* -------------------------------------------------------------------- */
  311. int SMS_open_dual_getnamevalue_numeric(char *name, long *value)
  312. {
  313. FILE  *fp[2];
  316. SMS_dual_openrc(fp);
  318. if (SMS_getnamevalue_numeric(fp[0], name, value) == 0)
  319. {
  320. SMS_dual_closerc(fp);
  321. return 0;
  322. }
  324. if (SMS_getnamevalue_numeric(fp[1], name, value) == 0)
  325. {
  326. SMS_dual_closerc(fp);
  327. return 0;
  328. }
  330. SMS_dual_closerc(fp);
  331. return -1;
  332. }
  335. /* -------------------------------------------------------------------- */
  336. /* -------------------------------------------------------------------- */
  337. void SMS_dual_closerc(FILE **fp)
  338. {
  339. SMS_close_smsrc(fp[0]);
  340. SMS_close_smsrc(fp[1]);
  341. }
  344. /* -------------------------------------------------------------------- */
  345. /* -------------------------------------------------------------------- */
  346. void SMS_dual_openrc(FILE **fp)
  347. {
  348. fp[0] = SMS_open_local_smsrc();
  349. if (fp[0] == NULL)
  350. { lprintf(LOG_VERBOSE, "Failed to open local smsrc filen");
  351. }
  353. fp[1] = SMS_open_global_smsrc();
  354. if (fp[1] == NULL)
  355. { lprintf(LOG_WARNING, "Failed to open global smsrc filen");
  356. }
  357. }
  360. /* -------------------------------------------------------------------- */
  361. /* -------------------------------------------------------------------- */
  362. static char *strdup_service(char *str)
  363. {
  364. char  *ptr,
  365. *dst,
  366. *service;
  369. service = (char *)malloc(sizeof(char) * (sms_strlen(str) +1));
  370. if (service == NULL)
  371. {
  372. lprintf(LOG_ERROR, "Allocating memoryn");
  373. exit(EMALLOC);
  374. }
  377. dst = service;
  378. ptr = str;
  379. while(*ptr != '')
  380. {
  382. if (*ptr == ':')
  383. { *dst = '';
  384. break;
  385. }
  386. else
  387. { *dst = *ptr;
  388. }
  390. dst++;
  391. ptr++;
  392. }
  394. if (*ptr == '')
  395. {
  396. *service = '';
  397. }
  399. return service;
  400. }
  403. /* -------------------------------------------------------------------- */
  404. /* -------------------------------------------------------------------- */
  405. static char *strdup_number(char *str)
  406. {
  407. char  *ptr,
  408. *dst,
  409. *number;
  412. number = (char *)malloc(sizeof(char) * (sms_strlen(str) +1));
  413. if (number == NULL)
  414. {
  415. lprintf(LOG_ERROR, "Allocating memoryn");
  416. exit(EMALLOC);
  417. }
  420. dst = number;
  421. ptr = str;
  422. while(*ptr != '')
  423. {
  424. if (*ptr == ':')
  425. { dst = number;
  426. }
  427. else
  428. { *dst = *ptr;
  429. dst++;
  430. }
  432. ptr++;
  433. }
  435. *dst = '';
  437. return number;
  438. }
  441. /* -------------------------------------------------------------------- */
  442. /* -------------------------------------------------------------------- */
  443. SMS_list *add_number(SMS_list *list, char *id, char *number, char *default_service)
  444. {
  445. char  *mnumber,
  446. *mservice;
  449. mnumber  = strdup_number(number);
  450. mservice = strdup_service(number);
  452. if (strcmp(mservice, "") == 0)
  453. {
  454. if (mnumber[0] != '_')
  455. {
  456. list = add_item(list, id, default_service, mnumber);
  457. }
  458. else
  459. {
  460. list = add_item(list, id, default_service, &mnumber[1]);
  461. }
  462. }
  463. else
  464. {
  465. if (mnumber[0] != '_')
  466. {
  467. list = add_item(list, id, mservice, mnumber);
  468. }
  469. else
  470. {
  471. list = add_item(list, id, default_service, &mnumber[1]);
  472. }
  473. }
  475. free(mnumber);
  476. free(mservice);
  478. return list;
  479. }
  482. /* -------------------------------------------------------------------- */
  483. /* -------------------------------------------------------------------- */
  484. static SMS_list *expandnumber(FILE *fp[2], char *id, char *str, char *default_service)
  485. {
  486. char  *src,
  487. *dst,
  488.   *number,
  489. *value;
  491. int  len, num;
  493. SMS_list
  494. *list,
  495. *sub_list;
  500. if (str == NULL)
  501. { return NULL;
  502. }
  505. len = sms_strlen(str);
  507. number = (char *)malloc(sizeof(char) * (len +1));
  508. if (number == NULL)
  509. {
  510. lprintf(LOG_ERROR, "Allocating memoryn");
  511. exit(EMALLOC);
  512. }
  515. list = NULL;
  516. dst = number;
  518. src = str;
  519. num = 1;
  520. while (*src != '')
  521. {
  522. if (*src == ',')
  523. {
  524. *dst = '';
  526. if (is_name(number))
  527. {
  528. /* Expand number */
  531. if (find_number(search_list, number) != NULL)
  532. {
  533. lprintf(LOG_WARNING, "Circular list detectedn");
  534. }
  535. else
  536. { search_list = add_item(search_list, "", "", number);
  538. value = SMS_dual_get_smsrc_value(fp, number);
  539. if (value != NULL)
  540. {
  541. sub_list = expandnumber(fp, number, value, default_service);
  542. list     = insert_list(list, sub_list);
  543. }
  544. else
  545. { list = add_number(list, id, number, default_service);
  546. }
  547. }
  548. }
  549. else
  550. { list = add_number(list, id, number, default_service);
  551. }
  553. dst = number;
  554. num++;
  555. }
  556. else
  557. { *dst = *src;
  558. dst++;
  559. }
  561. src++;
  562. }
  564. *dst = '';
  567. if (is_name(number))
  568. {
  569. /* Expand number */
  572. if (find_number(search_list, number) != NULL)
  573. {
  574. lprintf(LOG_WARNING, "Circular list detectedn");
  575. }
  576. else
  577. { search_list = add_item(search_list, "", "", number);
  579. value = SMS_dual_get_smsrc_value(fp, number);
  580. if (value != NULL)
  581. {
  582. sub_list = expandnumber(fp, number, value, default_service);
  583. list     = insert_list(list, sub_list);
  584. }
  585. else
  586. { list = add_number(list, id, number, default_service);
  587. }
  588. }
  589. }
  590. else
  591. { list = add_number(list, id, number, default_service);
  592. }
  595. free(number);
  597. return list;
  598. }
  601. /* -------------------------------------------------------------------- */
  602. /* -------------------------------------------------------------------- */
  603. SMS_list *SMS_expandnumber(FILE *fp[2], char *id, char *number, char *default_service)
  604. {
  605. SMS_list
  606. *list;
  609. search_list = NULL;
  610. list = expandnumber(fp, id, number, default_service);
  611. free_list(search_list);
  613. return list;
  614. }
  617. /* -------------------------------------------------------------------- */
  618. /* -------------------------------------------------------------------- */
  619. static void read_services(void)
  620. {
  621. char  fname[1024],
  622. dname[1024];
  623. int num,
  624. i;
  626. DIR  *dp;
  627. struct  dirent 
  628. *ep;
  631. sms_strcpy(dname, SERVICEDIR);
  632. sms_strcat(dname, "/services");
  634. dp = opendir (dname);
  635.         if (dp == NULL)
  636. { lprintf(LOG_ERROR, "Opening Services directory %sn", dname); 
  637. exit(-1);
  638. }
  640. num = 0;
  641. while ((ep = readdir(dp)))
  642. {
  643. if (ep->d_name[0] == '.')
  644. { continue;
  645. }
  647. num++;
  648. }
  650. SMS_services_list = (RESOURCE *)malloc(sizeof(RESOURCE) * (num +1));
  651. if (SMS_services_list == NULL)
  652. { lprintf(LOG_ERROR, "Allocating memory for SMS_services_listn");
  653. exit(-1);
  654. }
  657. i = 0;
  658. rewinddir(dp);
  659. while ((ep = readdir(dp)))
  660. {
  661. if (ep->d_name[0] == '.')
  662. { continue;
  663. }
  665. SMS_services_list[i].type = RESOURCE_STRING;
  667. SMS_services_list[i].name = malloc(sms_strlen("SMS_protocol_") + sms_strlen(ep->d_name) +1);
  668. if (SMS_services_list[i].name == NULL)
  669. { lprintf(LOG_ERROR, "Allocating memory for SMS_services_list[%d].namen", i);
  670. exit(-1);
  671. }
  673. sms_strcpy(SMS_services_list[i].name, "SMS_protocol_");
  674. sms_strcat(SMS_services_list[i].name, ep->d_name);
  676. SMS_services_list[i].found = 0;
  677. SMS_services_list[i].default_warning = 1; 
  678. SMS_services_list[i].str_value = NULL; 
  679. SMS_services_list[i].int_value = 0; 
  680. SMS_services_list[i].default_str_value = NULL; 
  681. SMS_services_list[i].default_int_value = 0; 
  682. SMS_services_list[i].var = NULL; 
  684. i++;
  685. }
  687. SMS_services_list[i].type = RESOURCE_NULL;
  688. SMS_services_list[i].name = NULL;
  689. SMS_services_list[i].found = 0;
  690. SMS_services_list[i].default_warning = 1; 
  691. SMS_services_list[i].str_value = NULL; 
  692. SMS_services_list[i].int_value = 0; 
  693. SMS_services_list[i].default_str_value = NULL; 
  694. SMS_services_list[i].default_int_value = 0; 
  695. SMS_services_list[i].var = NULL;
  697. sms_strcpy(fname, SERVICEDIR);
  698. sms_strcat(fname, "/sms_services");
  700. if (read_resource_file(fname, SMS_services_list, FALSE) != RESOURCE_FILE_OK)
  701. { lprintf(LOG_ERROR, "Unrecoverable Failure Parsing service file %sn", fname); 
  702. exit(-1);
  703. }
  704. }
  706. /* -------------------------------------------------------------------- */
  707. /* -------------------------------------------------------------------- */
  708. char *get_protocol(char *service)
  709. {
  710. char name[512];
  711. RESOURCE
  712. *resource;
  714. if (SMS_services_list == NULL)
  715. { read_services();
  716. }
  719. sms_strcpy(name, "SMS_protocol_");
  720. sms_strcat(name, service);
  722. resource = SMS_services_list;
  723. while (resource->type != RESOURCE_NULL)
  724. {
  725. if (strcmp(name, resource->name) == 0)
  726. { lprintf(LOG_VERBOSE, "Found %s = %sn", resource->name, resource->str_value);
  727. return resource->str_value;
  728. }
  730. resource++;
  731. }
  733. return NULL;
  734. }
  736. /* -------------------------------------------------------------------- */
  737. /* -------------------------------------------------------------------- */
  738. int validate_expanded_numbers(SMS_list *numbers)
  739. {
  740. DEVICE_ENTRY
  741. *device;
  743. char *id,
  744. *service,
  745. *protocol;
  747. int count;
  749. SMS_list
  750. *node;
  753. count = 0;
  755. node = get_first(numbers);
  756. while (node != NULL)
  757. {
  758. service  = get_service(node);
  759. protocol = get_protocol(service);
  761. device = get_device(protocol);
  762. if (device == NULL)
  763. { lprintf(LOG_ERROR, "Driver for service %s NOT foundn", service);
  764. count++;
  765. }
  766. else
  767. { id = get_number(node);
  769. if (!((*device->validate_id)(id)))
  770. {
  771. lprintf(LOG_WARNING, "Invalid id: %sn", id);
  772. count++;
  773. }
  774. }
  776. node = get_next(node);
  777. }
  779. return count;
  780. }
  783. /* -------------------------------------------------------------------- */
  784. /* -------------------------------------------------------------------- */
  785. int is_numeric(char *ptr)
  786. {
  787. while (*ptr != '')
  788. {
  789. if (!isdigit(*ptr))
  790. { return FALSE;
  791. }
  793. ptr++;
  794. }
  796. return TRUE;
  797. }